7 ms·
A Doom Renderer written in Rust
- Jemaclus 12y agoThis is awesome. Would you be interested in writing sort of a tutorial on building something like this? (Obviously much more basic, but still...)
- comex 12y agoThis is sort of off topic, but the fact that every change to the source requires (on my machine) 3-4 full seconds to recompile, without optimization, is indicative of the compiler performance problems that remain my main roadblock with Rust.
- ehsanu1 12y agoThe core devs are sympathetic (what with Rust being self-hosted) and apparently incremental compilation is coming soon: https://github.com/rust-lang/meeting-minutes/blob/master/weekly-meetings/2014-09-30.md#cycle-time https://github.com/rust-lang/meeting-minutes/blob/master/wee... There is also a way to parallelize compilation, which might sometimes speed things up, it's just not enabled by default yet: http://discuss.rust-lang.org/t/default-settings-for-parallel-codegen/519 http://discuss.rust-lang.org/t/default-settings-for-parallel...
- Skywing 12y agoI remember a day where I was proud that my C projects took a few seconds to compile. Made me feel like I had written something with some umph to it.
- melling 12y agoTurbo Pascal and Delphi had incredibly fast compilers. Why can't we make fast compilation a required feature today? We should never have to wait for the compiler/linker. http://prog21.dadgum.com/47.html http://prog21.dadgum.com/47.html
- deleted 12y ago[deleted]
- pcwalton 12y agoThey also didn't have the zero-cost memory safety abstractions that Rust has. Nor did they do much optimization. That said, we're working on compilation speed. The focus so far has been getting the language in shape and runtime performance of the generated code, not compilation speed (although we've picked most of the low-hanging fruit in compilation speed anyway).
- cageface 12y agoHow optimistic are you that the compilation speed can be significantly increased? Are there a lot of easy optimizations available or is this just the price paid for extra compile time safety? I'm not really a fan of Go but waiting for the compiler can be a pretty significant productivity killer on larger projects. Their fast compilation times are a pretty big selling point for what is (IMO) an otherwise underwhelming language design.
- pcwalton 12y ago> How optimistic are you that the compilation speed can be significantly increased? Are there a lot of easy optimizations available or is this just the price paid for extra compile time safety? The vast majority of compile time for optimized builds (80%-90%) is spent in code generation and optimization in LLVM. For unoptimized builds, most of the compile time is spent in the typechecker doing type unifications for method lookup. With some optimizations to quickly reject method candidates I suspect this can be greatly improved. Incremental compilation for the fast turnaround is being worked on and there has been significant progress, to address comex' complaint. > Their fast compilation times are a pretty big selling point for what is (IMO) an otherwise underwhelming language design. Go 6g/8g also doesn't do much optimization by comparison to GCC/LLVM. (Rust uses LLVM.)
- pjmlp 12y ago
- reubenmorais 12y agoHave you profiled the build? Is most of it spent in the compiler? A more practical point is that the main competitor is C++, a language notorious for long compilation times, so not-ultra-fast compile times might not be the highest priority for people working on rustc.
- fspeech 12y agoC++ compilers are very fast (I would say amazingly fast) unfortunately atrocious header only implementations like Boost drags it down. I just did clang++ -E on a single #include of cpp-netlib which depends on Boost asio and the dumped output came to: $ wc test1 279506 897765 10174700 test1 And this is after enabling dynamic linking which cuts down a few thousand lines. Library writers are not giving compiler writers a break! I find this practice atrocious. People should be able to just import the interface instead the whole implementation of everything (and enable "headers only" feature at the end if so desired to eliminate the need of linking).
- yoklov 12y agoErr, header-only libraries exist mostly because templates require them, not because people don't like linking (well, there's some of that too, but it's the minority).
- pjmlp 12y agoWalter Bright, the author of D and the first real C++ native compiler (Zortech C++), explains it http://www.drdobbs.com/cpp/c-compilation-speed/228701711 http://www.drdobbs.com/cpp/c-compilation-speed/228701711 Compatibility with C tooling is also a big reason, as templates can only be header only to be consumed by other translation units. Unfortunately "export template" was a failed experiment. Now C++ developers need to wait until C++17 for modules, if they ever get into the standard. And if they do, most likely it will take until around 2020 for all major C++ compilers across embedded, desktop and server systems offer support for it. Now the question is, if one is willing to wait that long or rather use a language that can use modules today.
- lultimouomo 12y ago
- smosher_ 12y ago(Even more OT and not a criticism of you comment.) I wish someone could send your comment back in time so I could have read it when Doom was first released. I think it took longer just to get the game started up back then.
- pcwalton 12y agoSounds like that's mostly the lack of incremental compilation, which is being worked on.
- adamnemecek 12y agoIt's probably better that before 1.0, the development effort concentrates on getting the language right rather than compilation speed which can be fixed later.
- steveklabnik 12y agoWhile this is true, it's also important that things aren't introduced which make these kinds of optimizations impossible. I think we've done a good job of that, but it is something to keep in mind.
- spullara 12y agoIt is in the top 3 issues with Scala as well. The amount of drag it causes in a project just isn't worth it.
- eropple 12y agoFWIW, I don't find it to be a big issue in Scala anymore with SBT's incremental compilation.
- spullara 12y agoDepends on how many people are developing on the code base. If every morning is a full build with a few spread throughout the day for integration it is pretty awful. Additionally, I think submit queues are the way to go for committing code to master and if that takes an hour before you know your change is good I'm pretty unhappy. As far as incremental compiles go, just developing in IDEA does a pretty good job.
- pcwalton 12y agoThe Rust compiler is much faster than Scala's compiler, from everything I have heard.
- Alupis 12y agoreally doesn't matter how long the compiler takes, so long as the result is fast.
- pjc50 12y ago3-4 seconds is extremely fast if you're coming from the C/C++ world. I can't see how this could possibly be a roadblock.
- comex 12y agoNot for incremental compilation when a single file changed, without optimization, it's not - depending on the type of change, of course, and how heavy the C++ code in question is, and I guess on whether you're using a broken IDE/build system (my standard is the command line, using make for small projects and ninja for larger ones). And incremental compilation can scale up to much larger projects without increasing the time much, whereas in Rust that would require splitting up into crates and even then would frequently require a full rebuild due to the coarse dependency tracking of "anything in this crate changed -> rebuild all dependents". That said, I expect incremental compilation built into rustc to greatly improve the situation - if done right, it should easily beat C++, although I don't know the details of the plan - so I'm happy someone is working on it. (In the past I wanted to work on it myself, but I was in a big generally unproductive slump..)
- simias 12y agoC++ definitely if you're using heavily templated code, C not so much though. Although I agree with your point, I've been using Rust quite a lot lately and compilation time was never an issue so far.
- phaylon 12y agoAnother thing which I don't see often mentioned, but which alleviate most of the compile-time waiting-pain for me (and I'm actually a dynamic language guy) is the fact that since optimizations are usually what takes longest, the compiler is quite quick about telling me about errors. But maybe my projects just haven't been big enough :)
- angersock 12y agoOh, Gods, 3-4 full seconds, perish the thought. That's really not that long a time at all.
- bmh100 12y agoThese are really valuable projects. It's not only a nostalgic project to hack on. It's also a learning tool for those interested in game programming, idiomatic Rust, and C-to-Rust conversion. Even building complex software from requirements. Thank you, Cristi Cobzarenco.
- shmerl 12y agoHow does it interact with OpenGL? Using C bindings?
- hornetblack 12y agoIt uses gl-rs. Which auto generates a rust wrapper around the C bindings using a compiler plugin. https://github.com/bjz/gl-rs https://github.com/bjz/gl-rs
- shmerl 12y agoThanks for the pointer!
- bjz_ 12y agoWe have a syntax extension that uses kronos' xml registry (https://www.opengl.org/registry/#specfiles https://www.opengl.org/registry/#specfiles) to generate symbol a loader (somewhat like GLEW) at compile time. https://github.com/bjz/gl-rs https://github.com/bjz/gl-rs
- shmerl 12y agoThanks for the pointer!
- aidos 12y agoOT but it's wonderful to see those screenshots again. It's been decades since I played that game and I can still remember the hidden tricks in those rooms.
- TIHan 12y agoThis is very cool. Really love seeing devs doing stuff like this.
- Alupis 12y agowhy do these post's titles keep getting moderated? "Doom I/II written in Rust" is a fine title for what this is.
- yen223 12y agoStuff like that is the reason why I'm excited for Rust's future. It's really an amazing language.
- PuercoPop 12y agoA similar project, Quake 2 map renderer written with Julia https://github.com/jayschwa/Quake2.jl https://github.com/jayschwa/Quake2.jl
- pjmlp 12y agoThis is cool! Thanks for posting it.
- temuze 12y agoHoly crap, this is f*ing awesome. Rust has made systems programming exciting for me again. Seeing well written Rust code like this (also, the repos on Github https://github.com/trending?l=rust https://github.com/trending?l=rust) has been a really good learning experience. As a Rust newbie, I only wish there were better examples of testing in public Rust repos.
- jnbiche 12y ago>As a Rust newbie, I only wish there were better examples of testing in public Rust repos. Testing is incredibly easy. The reason you may have missed the testing is that tests are often in the same file as tested code. Go back and check, it's very common in Rust to test your code. And it's as simple as writing: #[test] on the line before your unit test function, and then using some of the unit test macros in std like `assert` and `assert_eq` along with `fail` to perform the tests[1]. Then you test your code by running the normal rustc command but with the `--test` flag. A test runner with very attractive output is built into the compiler. Rust unit testing is just about the easiest testing I've ever used, right up there with golang. I love that it's built into the language. Also, the `cargo` package manager makes everything -- including unit testing -- incredibly convenient. And I say this as someone who cringes every time a language comes out with yet another package manager or build tool (ahem, .js). But in the case of rust's cargo, it's incredibly worth it to use a new package manager, and so much better than a Makefile (although it's quite easy to integrate makesfiles with cargo). 1. http://doc.rust-lang.org/std/index.html http://doc.rust-lang.org/std/index.html
- yen223 12y agoOne of the huge wins of rust is that the devs put a lot of effort into its basic infrastructure. Testing, documenting, and benchmarking are almost too easy.
- steveklabnik 12y agoThe guide has a whole section on this: http://doc.rust-lang.org/guide.html#testing http://doc.rust-lang.org/guide.html#testing And we even have a full guide on testing, though I haven't checked it lately: http://doc.rust-lang.org/guide-testing.html http://doc.rust-lang.org/guide-testing.html (it's on the todo list)
- deleted 12y ago[deleted]
- deleted 12y ago[deleted]