
Using Rust in Windows - miqkt
http://www.jonathanturner.org/2017/03/rust-in-windows.html
======
Arnavion
Also, if using VS2017, you may also have to set the env var
`VisualStudioVersion` to `15.0` to get some cmake-using crates (libssh2-sys,
etc) to build. See [https://github.com/alexcrichton/cmake-
rs/pull/16#issuecommen...](https://github.com/alexcrichton/cmake-
rs/pull/16#issuecomment-285932296)

(Note that 15.0 == VS2017, not VS2015)

~~~
topbanana
Or run Cargo from the VS 2017 developer command prompt

------
steveklabnik
I recently switched to using Windows full-time. It started off using the Linux
subsystem, but then I accidentally trashed it. So I'm now using native
Windows. Powershell is surprisingly easy to adapt to, and while I still use
vim often, I've been enjoying occasional use of VS: Code.

Most stuff Just Works, but there are still some rough edges. A lot of them are
simply "I'm not used to the Windows Way" yet instead of Rust problems, though.

~~~
egeozcan
How did you manage to trash the WSL? I'm not suggesting that it's hard to do
or anything, just genuinely curious.

~~~
steveklabnik
I decided to try using VS: Code (which was installed under Windows) to work on
my projects. Opening a file ends up trashing it entirely. This is actually
expected behavior; I just wasn't aware :(

~~~
slrz
What? Files get trashed by just opening them? _This_ is supposed to be
expected behaviour?

~~~
steveklabnik
Yes. Native windows doesn't know how to read the filesystem, so it totally
screws up the metadata.

It's actually kinda hard to even do; the files are hidden by default, so you
have to really go snooping to do this.

Linux -> Windows works just fine. Windows -> Linux, not so much.

------
gepi79
Thanks. I made a complementary guide to use the visual studio build tools
2017.
[http://lustysociety.org/programming/how_to_rust_language_vis...](http://lustysociety.org/programming/how_to_rust_language_visual_studio_2017_windows_10)

------
rukenshia
It's way too hard to get anything that requires OpenSSL to work, I decided not
to write Rust code on my windows PC because of that. I remember the process of
just getting it to work as really painful and time consuming. Other than that
I really enjoy writing rust code on my Linux machine.

~~~
aidanhs
Fwiw, native-tls [0] is intended to solve this problem for the set of uses
involving TLS (e.g. hyper [1], reqwest) by using the defacto standard on the
platform you're on. This means no openssl is necessary on Windows.

Longer term, I would like to see some way for a crate consumer to optionally
replace openssl with ring [2] where possible. But that's a harder problem,
figuring out a common interface, specifying two crates satisfy that interface
and are swappable by cargo...classic package management problems really.

[0] [https://github.com/sfackler/rust-native-
tls](https://github.com/sfackler/rust-native-tls)

[1] [https://docs.rs/hyper-native-
tls/0.2.2/hyper_native_tls/](https://docs.rs/hyper-native-
tls/0.2.2/hyper_native_tls/)

[2] [https://github.com/briansmith/ring](https://github.com/briansmith/ring)

~~~
valarauca1
Rustls[1] is a work in progress to build a TLSv1.3 Server in 100% safe Rust.
Uses Ring for crypto.

It could use more contributors/eyes/auditors. It works out of the box on
Windows currently.

[1] [https://github.com/ctz/rustls](https://github.com/ctz/rustls)

------
joaomoreno
Visual Studio Code has a pretty decent Rust extension:
[https://marketplace.visualstudio.com/items?itemName=kalitaal...](https://marketplace.visualstudio.com/items?itemName=kalitaalexey.vscode-
rust)

~~~
steveklabnik
Note that this is the up-to-date fork of the older "RustyCode" extension.

------
vog
Does is also work with the Free-Software MinGW toolchain?

That would make it possible to generate Windows binaries without having to run
a Windows VM, through cross-compiling, using e.g. MXE:
[http://mxe.cc/](http://mxe.cc/)

~~~
jix
It does. It supports mingw on windows as well as cross-compiling from linux
using cargo (rust's package manager and build tool). Installing mingw-w64 from
my distribution's package manager and telling cargo where to find its linker
and assembler was all I needed to cross compile stand alone windows binaries
of some command line tools I wrote.

------
vvanders
Been working with Rust on Windows for almost a year now.

My go-to is VSCode + Rust plugin. You get the same debugging as VS2015 via C++
plugin(they both use the same backend). Only time I need to drop over to MSVC
is if I need data breakpoints or look at disassembly(usually when I'm dealing
with a C library that's misbehaving).

VSCode rust plugin gets you racer, rustfmt and a bunch of other goodies(cargo
test/check right in the IDE).

~~~
btkramer9
Have you found any good resource on setting up the debugger for rust in
VSCode? I've been having issues getting this running smoothly and have found
very little support online

~~~
steveklabnik
I am literally fighting with this right now. LLDB is not a happy camper.

~~~
vvanders
Yeah, MSVC target tends to work much better(although viewing of some more
complex types doesn't work yet).

~~~
steveklabnik
I'm using the MSVC build of Rust. That doesn't preclude using lldb as a
debugger.

~~~
vvanders
Yeah, I meant MSVC debug backend.

------
Animats
What's the situation with using the Windows API from Rust? Are you down at the
Win32 API level, or can you even do that?

~~~
lifthrasiir
Winapi-rs [1] is the de-facto binding for the Windows API and covers a lot of
them (but not yet complete). I don't see a significant project for higher-
level bindings.

[1] [https://github.com/retep998/winapi-
rs/](https://github.com/retep998/winapi-rs/)

------
tracker1
I should really find some time to upgrade to VS2017, my understanding is it's
a bit faster than VS2015, not just the install. Can anyone comment on this, I
always found VS to be a beast, even on an SSD, HDDs being nearly unbearable.

I really do like VS Code though... looks like there's some work going there.

~~~
ranveeraggarwal
VS17 has an option to "quick load" projects. It loads up in a jiffy (unlike
it's previous versions), but you cannot use some of the IDE features.

I seriously hope they add a lazy load feature in the future.

~~~
oblio
Isn't quick load just a rename of lazy load, based on your description?

~~~
ranveeraggarwal
Nope, apparently quick load doesn't load several IDE features at all. What I
mean by lazy load is that it should incrementally load the IDE features after
the IDE starts.

~~~
StavrosK
Jeez, the obvious optimization would have been to load some of the features
first and then load the rest, but to not load them at all? That's not very
useful.

~~~
oblio
Well, as a back-seat commenter I agree with you but they probably had a good
reason to not do it. Most likely something to do with development complexity.
There's a ton of smart people working on Visual Studio, I'm willing to trust
their judgment on this :)

~~~
StavrosK
Well, they definitely had good reason, it's just that the feature isn't very
useful without the extra work. Although, I don't know exactly how much
functionality is missing, so I might be wrong.

~~~
oblio
Well, it might just be laying the groundwork for lazy loading. They probably
thought some people might find it useful even as a "half feature".

~~~
StavrosK
Yeah, that seems like the most reasonable explanation. It sounds like the
answer was just "deadline".

------
frik
Instead of VS try out IntelliJ IDEA with Rust plugin: [https://intellij-
rust.github.io](https://intellij-rust.github.io)

It gives you the comfort features known from the IntelliJ platform and doesn't
add phonehome telemetry to your exe files (like VS2k15).

~~~
jsmeaton
Have you got a source for the telemetry inside the compiled binary claim?

~~~
yuriks
It was something a specific patch version (of Update 2, iirc) did which was
blown way out of proportion. The CRT in that version sent two events on
startup and shutdown to the windows event tracing/profiling framework. (Which
show up in performance analysis tools like WPA.) People just latched onto the
scary name.

~~~
oblio
To make things even worse (even funnier?), GCC also has something like this, I
believe it's this feature:
[https://gcc.gnu.org/onlinedocs/gcc/Instrumentation-
Options.h...](https://gcc.gnu.org/onlinedocs/gcc/Instrumentation-Options.html)

~~~
dom0
Profiling is not telemetry. Telemetry implies that events are supposed to be
transmitted off-site (tele + metry = remote + measuring). Profiling writes a
local file with statistics.

------
ranveeraggarwal
I personally prefer lxss. While it has some limitations, I am yet to face
issues with rust projects. You can also use Intellij-based IDEs with a rust
plugin and run `bash` in the command prompt accompanying the IDE. It feels
like working on Linux ^_^

~~~
Longhanks
Well, because the userland IS Linux (or what people refer to as Linux on the
desktop).

But binaries are also ELF binaries and can only be run with lxss. How do you
deploy to Windows customers who are not developers?

~~~
problems
You dev on linux, try your best to write in a cross-platform way - then only
once you've got something that works and you're fairly motivated to actually
do something with it, go through the hassle to make a Windows build.

------
jayflux
Is VisualRust still active? It seems dead or moving very slowly. I know
there's some commits going into the project, but their last release was over a
year ago.

