> Unless you're expecting some sort of blind worship, I expect pointers to source code. I found libstd/gc.rs, so I'll assume that it's what you're talking about. Let's see what's "basically" done, shall we?
https://github.com/graydon/rust/tree/gc-prefix
> Learn to treat people with respect
I don't really want to draw out this argument, but I called your reply FUD because you were claiming things that were not true, such as that we cannot implement tracing GC.
In The Future of Programminggraydon
rust
Rust2010–2013
graydon / rust
rust
personal fork for work on rust language
17Distinct people
20Mentions
1Explicit recommenders
233GitHub stars
What to know before exploring
What it is
personal fork for work on rust language
GitHub
Where it is used
No documented product use was verified in the last source check.
What people are saying
I love Firefox (and Chrome! no need to be zealots :D ), but I'm even happier that this means there will be no interruption to the full-time development of Mozilla's new systems…
kibwen used a recommendation phrase. One indexed comment matches. This is a phrase match, not a verdict.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
No other repository is repeatedly linked in the same discussions.
This week on Hacker News
Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 1:49:46 PM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year20 dated mentions
Observed mentions: 2010-07-08 22:49:05 UTC to 2013-07-31 14:09:41 UTC.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2010 | 2010-01-01 00:00:00 UTC | 2011-01-01 00:00:00 UTC | 5 | 1 | 4 |
| 2011 | 2011-01-01 00:00:00 UTC | 2012-01-01 00:00:00 UTC | 11 | 0 | 11 |
| 2012 | 2012-01-01 00:00:00 UTC | 2013-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2013 | 2013-01-01 00:00:00 UTC | 2014-01-01 00:00:00 UTC | 3 | 0 | 3 |
From the project README
An excerpt from the repository, fetched Nov 13, 2026.
Read the project’s introduction
The Rust Programming Language
This is the main source code repository for Rust. It contains the compiler,
standard library, and documentation.
Note: this README is for users rather than contributors.
If you wish to contribute to the compiler, you should read the
Getting Started section of the rustc-dev-guide instead.
You can ask for help in the #new members Zulip stream.
Quick Start
Read "Installation" from The Book.
Installing from Source
The Rust build system uses a Python script called x.py to build the compiler,
which manages the bootstrapping process. It lives in the root of the project.
The x.py command can be run directly on most systems in the following format:
./x.py <subcommand> [flags]
This is how the documentation and examples assume you are running x.py.
Systems such as Ubuntu 20.04 LTS do not create the necessary python command by default when Python is installed that allows x.py to be run directly. In that case you can either create a symlink for python (Ubuntu provides the python-is-python3 package for this), or run x.py using Python itself:
# Python 3
python3 x.py <subcommand> [flags]
# Python 2.7
python2.7 x.py <subcommand> [flags]
More information about x.py can be found
by running it with the --help flag or reading the rustc dev guide.
Building on a Unix-like system
Make sure you have installed the dependencies:
g++ 5.1 or later or clang++ 3.5 or later
python 3 or 2.7
GNU make 3.81 or later
cmake 3.13.4 or later
ninja
curl
git
ssl which comes in libssl-dev or openssl-devel
pkg-config if you are compiling on Linux and targeting Linux
Clone the source with git:
git clone https://github.com/rust-lang/rust.git
cd rust
Configure the build settings:
The Rust build system uses a file named config.toml in the root of the
source tree to determine various configuration settings for the build.
Copy the default config.toml.example to config.toml to get started.
cp config.toml.example config.toml
If you plan to use x.py install to create an installation, it is recommended
that you set the prefix value in the [install] section to a directory.
Create install directory if you are not installing in default directory
Build and install:
./x.py build && ./x.py install
When complete, ./x.py install will place several programs into
$PREFIX/bin: rustc, the Rust compiler, and rustdoc, the
API-documentation tool. This install does not include Cargo,
Rust's package manager. To build and install Cargo, you may
run ./x.py install cargo or set the build.extended key in
config.toml to true to build and install all tools.
Building on Windows
There are two prominent ABIs in use on Windows: the native (MSVC) ABI used by
Visual Studio, and the GNU ABI used by the GCC toolchain. Which version of Rust
you need depends largely on what C/C++ libraries you want to interoperate with:
for interop with software produced by Visual Studio use the MSVC build of Rust;
for interop with GNU software built using the MinGW/MSYS2 toolchain use the GNU
build.
MinGW
MSYS2 can be used to easily build Rust on Windows:
Grab the latest MSYS2 installer and go through the installer.
Run mingw32_shell.bat or mingw64_shell.bat from wherever you installed
MSYS2 (i.e. C:\msys64), depending on whether you want 32-bit or 64-bit
Rust. (As of the latest version of MSYS2 you have to run msys2_shell.cmd -mingw32 or msys2_shell.cmd -mingw64 from the command line instead)
From this terminal, install the required tools:
# Update package mirrors (may be needed if you have a fresh install of MSYS2)
pacman -Sy pacman-mirrors
# Install build tools needed for Rust. If you're building a 32-bit compiler,
# then replace "x86_64" below with "i686". If you've already got git, python,
# or CMake installed and in PATH you can remove them from this list. Note
# that it is important that you do **not** use the 'python2', 'cmake' and 'ninja'
# packages from the 'msys2' subsystem. The build has historically been known
# to fail with these packages.
pacman -S git \
make \
diffutils \
tar \
mingw-w64-x86_64-python \
mingw-w64-x86_64-cmake \
mingw-w64-x86_64-gcc \
mingw-w64-x86_64-ninja
Navigate to Rust's source code (or clone it), then build it:
./x.py build && ./x.py install
MSVC
MSVC builds of Rust additionally require an installation of Visual Studio 2017
(or later) so rustc can use its linker. The simplest way is to get the
Visual Studio, check the “C++ build tools” and “Windows 10 SDK” workload.
(If you're installing cmake yourself, be careful that “C++ CMake tools for
Windows” doesn't get included under “Individual components”.)
With these dependencies installed, you can build the compiler in a cmd.exe
shell with:
python x.py build
Currently, building Rust only works with some known versions of Visual Studio. If
you have a more recent version installed and the build system doesn't understand,
you may need to force rustbuild to use an older version. This can be done
by manually calling the appropriate vcvars file before running the bootstrap.
CALL "C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvars64.bat"
python x.py build
Specifying an ABI
Each specific ABI can also be used from either environment (for example, using
the GNU ABI in PowerShell) by using an explicit build triple. The available
Windows build triples are:
GNU ABI (using GCC)
i686-pc-windows-gnu
x86_64-pc-windows-gnu
The MSVC ABI
i686-pc-windows-msvc
x86_64-pc-windows-msvc
The build triple can be specified by either specifying --build=<triple> when
invoking x.py commands, or by copying the config.toml file (as described
in Installing From Source), and modifying the
build option under the [build] section.
Configure and Make
While it's not the recommended build system, this project also provides a
configure script and makefile (the latter of which just invokes x.py).
./configure
make && sudo make install
When using the configure script,
Read the full README on GitHubWhat Hacker News says
20 sourcesThere is a branch with a GC written in Rust: https://github.com/graydon/rust/tree/gc
In Removing garbage collection from the Rust language> - Write a Rust garbage collector in Rust, hell, rewrite the Rust runtime in Rust.
The runtime is currently being rewritten to Rust[1], and the GC-in-Rust is almost complete[2] (as far as I understand it).
[1]: Work in progress: https://github.com/mozilla/rust/tree/incoming/src/libstd/rt
[2]: https://github.com/graydon/rust/tree/gc
In Zero.rs: runtime-less Rust programshttps://github.com/graydon/rust/wiki/Doc-language-FAQ
Has a section called: "Have you seen this Google language, Go? How does Rust compare?"
Excerpt: "Go adopted semantics (safety and memory model) that are quite unsatisfactory." Like Null pointers, global GC, shared mutable state etc.
In Rust - a new programming language from MozillaI love Firefox (and Chrome! no need to be zealots :D ), but I'm even happier that this means there will be no interruption to the full-time development of Mozilla's new systems programming language, Rust:
http://www.rust-lang.org/
https://github.com/graydon/rust
Coincidentally, for those who like to make much ado about Mozilla vs. Google, Rust has a lot of similarities to Go. (As both projects began as semi-secret, low-key affairs, this is due more to convergent evolution than anything.)
In Mozilla and Google Sign New Agreement for Default Search in FirefoxNot entirely the same, but check Mozilla's rust (still in progress) - https://github.com/graydon/rust/wiki
In Why Not Haskell?Check out the macro tests in this directory: https://github.com/graydon/rust/tree/master/src/test/run-pas...
In The Rust Programming LanguageLanguage innovation is tightly tied into computer science innovation. There are plenty of paradigms that are fundamentally different and quite potentially better than UNIX and LISP out there- you just need to get out of that rut.
Mozilla's language [Rust](https://www.github.com/graydon/rust/wiki) is working on static verification (using typestate) and concurrency in a C/C++ level language.
The Haskell community has several people ([Conal Elliot](http://conal.net), [Luke Palmer](http://lukepalmer.wordpress.com)) who are working on new models of functional I/O such as functional reactive programming.
There is a lot of programming language innovation in parallel/concurrent programming that's just hitting mainstream- actor model, asynchronous programming, CUDA/OpenCL, etc.
The way you talk to the machine is an extremely important part of "how
Read the rest
to get problems solved." If you can't express something without absurd amounts of overhead, you're not going to solve the problem that way.
Mozilla is working on Rust https://github.com/graydon/rust/wiki/Language-FAQ. Google has Go http://golang.org/.
To run compiled binaries from such languages you'll use Native Client http://code.google.com/p/nativeclient/ and Pepper APIs which let you access HTML5.
Go gets rid of some insecure low level things like pointers, keeps such things in an unsafe package to discourage its use. They intend to make it seamlessly compatible with NaCl. C/C++ code needs to be modified to work there.
JS is already not suitable for lots of stuff. Vendors are stretching its capabilities with big teams of fancy programmers implementing fancy VMs with big chunks written in assembler. At Google I/O they mentioned V8 is about as fast as it will get. Then bigger teams are writing massive APIs because even with fast VMs the language isn't fast enough to roll yo
Read the rest
ur own CSS/XAML/MXML/HTML parsers or 2D rendering contexts. So you're forced to wait or hack together things like LESS, CoffeeScript, Stylus in an attempt to communicate with the overlords.
With the browsers becoming the operating system for many users, you need a runtime that's as powerful as a regular operating system. Google and Mozilla are major players and it's nice to see them exploring alternatives.
But even if NaCl/Go is superior technologically, it may not overcome JavaScript's business and political momentum. As usual, technology is not chosen based on technological merit, but business considerations like legacy, lock in, etc. Perhaps NaCl/Go approach will succeed but it will be too little too late. Kinda feels that way with Flash and Browsers, they're finally serious platforms but might be too far behind Objective-C, C# and Java on mobiles.
I'm biased, of course, because I work on Rust full-time, but don't forget Rust: https://github.com/graydon/rust
We recently reached self-hosting status, in which we compiled Rust with itself, and over the past few weeks we've been working on making the compiler much faster (over 7x in fact).
In C to Go: Could Go replace C?You can learn to be useful in Go in about 5 minutes, and it has some extremely convenient support for concurrency.
On the flipside, I think learning OCaml (if you've no experience with that family) will make you smarter in a way that Go won't. Of the two, given someone that knew neither: if you want to learn something learn OCaml, if you want to do something use Go.
Aside: speaking of OCaml and new languages, have you looked at Rust? https://github.com/graydon/rust/wiki - it was bootstrapped in OCaml.
In New stable release of Go> IDEA: If someone had an augmented ref-counting system with a runtime containing an optional cycle-detector and something like LINT but for the runtime reference graph, one would get most of the benefits of GC with the efficiency of the ref-counting system. I half expect someone to tell me that this already exists for Python.
Or you could do what Rust <https://github.com/graydon/rust/wiki/Language-FAQ>; does, and have different types of objects; stateful and stateless. Stateless object cannot have cycles (since you can't construct them in stateless objects, unless you're in a lazy language), and so reference counting can be used for stateless objects. Stateful objects, which can have cycles, are managed by the garbage collector.
Rust sounds like a really interesting idea, and I'd love to give it a try, but sadly it's still in the "some a
Read the rest
ssembly required" stage as they work on bootstrapping it so the only real projects that are worthwhile to do with it yet are helping out with the bootstrapping process.
For higher-level systems programming (ie not bare metal) I think the approach taken by the Rust language is interesting. Mutable data structures are thread-local and are GCed (GC happens independently per thread). Immutable data structures can be passed between threads, are reference counted and support RAII.
https://github.com/graydon/rust/wiki/Language-FAQ
In Linus Torvalds on Garbage Collection (2002)I'm glad that systems languages are getting a little more love these days. However, I'm a little saddened to see that no one seems to want to write a language that can also be used at the write-a-kernel level. Both Rust and GoLang have expressly made this a non-goal[1][2].
[1] https://github.com/graydon/rust/wiki/Project-FAQ
[2] http://groups.google.com/group/golang-dev/browse_thread/thre...
In A Quick Look at the Rust Programming LanguageSimilarly, I've been hoping that Rust (which is somewhat run by Mozilla labs folks) would turn out well:
https://github.com/graydon/rust/wiki/
In C++ in Coders at WorkShowing the 15 most recent of 20 sources. Enable JavaScript to search and browse every indexed mention.