fls

It's a work in progress. The Reference (https://doc.rust-lang.org/reference) is slowly getting more complete over time. Other ongoing efforts include a-mir-formality (https://github.com/rust-lang/a-mir-formality), minirust (https://github.com/minirust/minirust), the FLS (https://github.com/rust-lang/fls), and Rust via Desugarings (https://nadrieril.github.io/rust-via-desugarings/). But writing a 100% complete and correct formal spec is hard! Not even C gets this right, the C standard has holes which lead to miscompilations and UB in practice: https://www.ralfj.de/blog/2020/12/14/provenance.html

Flagged for deliberately spreading disinformation under the name StopDisinfo. As this user is aware, rust has a specification https://github.com/rust-lang/fls, which they have previously commented on: https://news.ycombinator.com/item?id=44927141 (and which I probably wouldn't have remembered if not for the rather remarkable name they are saying false things under). Rust also has multiple compilers (rustc, mrustc, and gccrs) though only one is production ready at this time.

It's worth pointing out that you can absolutely use Rust without Cargo and crates.io and the culture that comes with. You'll be swimming up against the stream. But arguably it makes sense for certain kinds of projects. I'd classify OS kernel and DB internals development as being those kinds of projects, TBH. Keep your dependency set extremely minimal, vendor it, and avoid crates.io entirely. I don't actually run into nightly requirements... ever? These days. Progress on language specification is good https://github.com/rust-lang/fls

Rust then? From "The state of Rust trying to catch up with Ada [video]" https://news.ycombinator.com/item?id=43007013 : > [awesome-safety-critical] > rustfoundation/safety-critical-rust-consortium: https://github.com/rustfoundation/safety-critical-rust-conso... rust-lang/fls: https://github.com/rust-lang/fls How does what FLS enables compare to these Safe C++ proposals? Safe C++ draft: https://safecpp.org/draft.html

There's still work being done on the Reference, which is being maintained in the same way as it has been since the Rust documentation team was disbanded in 2020. But it's a very long way from being either complete or correct enough to reliably answer questions about Rust-the-language. After the "write a new spec" plan was abandoned in 2024 the next stated plan was to turn the Reference into the spec, though they never got as far as deciding how that was going to work. That plan lasted six months before they changed direction again. The only practical effect was to add the paragraph identifiers like [destructors.scope.nesting.function-body]. They're currently arguing about whether to write something from scratch or somehow convert the FLS[1] into a spec. [1]: https://github.com/rust-lang/fls

A year or so ago I read through one smallish section (basically function calls) and filed issues for the problems I found that were easy to write up crisply. They fixed the easy bugs: https://github.com/ferrocene/specification/issues/453 https://github.com/ferrocene/specification/issues/454 https://github.com/ferrocene/specification/issues/455 https://github.com/ferrocene/specification/issues/458 https://github.com/ferrocene/specification/issues/459 https://github.com/ferrocene/specification/issues/460 https://github.com/ferrocene/specification/issues/461 https://github.com/ferrocene/specification/issues/463 https://github.com/ferrocene/specification/issues/464 But they didn't try to fill the gaps: https://github.com/ferrocene/specification/issues/462 https://github.com/ferrocene/specification/issues/465 https://github.com/ferrocene/speci

It does have a specification: https://github.com/ferrocene/specification It also strikes me as extraordinarily unlikely that any formal verification effort will use the existing specification, and not build their own (using their own formal language) as they go.

Many people misunderstand how software is written in regulated industries, and assume that a standard is necessary. In practice, this is not the case. Note that Ferrocene[1] had to produce a specification[2] in order to qualify the compiler. But there isn't a requirement that it must be a standard in any way, only that it describes how the Ferrocene compiler works. Nor that it be accepted by upstream. 1: https://ferrous-systems.com/blog/officially-qualified-ferroc... 2: https://github.com/ferrocene/specification

Ferrous created a language specification. https://github.com/ferrocene/specification They do say any differences between it and upstream behavior or documentation is a defect in the spec, not upstream. So it isn't authoritative. Unless we all decide it is.

>> The spec does not define the software. The software is as the software does. Having or not having a spec doesn't protect from bugs - people do. >> What you're taking about is covering one's ass, not specification. They are related. In safety-critical software, bugs can cause people to die. Without a spec, no one will use Rust for safety critical software. It would be too risky and no company would accept that level of risk. For example if software that controls an airplane is written in Rust and an error occurs during flight, what happens? The software can't just panic and crash or the airplane might crash. The Ferrocene project (https://ferrous-systems.com/ferrocene/) is working on producing a safety-critical Rust specification (https://github.com/ferrocene/specification) because having a language specification matters for safety-c

>> Rust is defined by the implementation. Hopefully not for long: https://github.com/ferrocene/specification https://ferrous-systems.com/blog/the-ferrocene-language-spec... Hopefully Ferrocene can lead to Rust itself being standardized. To me, it seems inevitable that there will be multiple implementations of Rust, especially if Rust continues to be more widely adopted and used in new domains. I would also not be surprised if Rust were to adopt optional language extensions for specialized use cases, similar to Ada's language annexes: http://www.ada-auth.org/standards/22rm/html/RM-1-1-2.html Why? Because the Rust implementation you use for video game programming does not need all of the same features as the Rust implementation that you use for safety-critical embedded systems (for example: railroad control software).