Update (2018-06-04): The call for maintainers has been answered. Stay tuned.
When we set out to build Gotham, we had some main ideas that helped to shape it:
A framework that runs on stable Rust, taking advantage of as much as possible
of what it offers;
A framework that allowed us to write applications in the way we wanted to
A learning experience and experiment in what we could achieve with the goal of
building a useful web framework.
We’re excited about the framework we’ve built and the ideas we’ve put into it,
but have paused to consider Gotham’s present and future position and want to
share these thoughts with the community.
Major changes in the ecosystem
The current state of the web ecosystem in Rust is one of flux. There are some
major efforts underway which will improve the future of both web and
asynchronous applications (in no particular order):
Tokio reform and its wider adoption by the community
The experimental Futures 0.2, and the upcoming Futures 0.3
Wider adoption of the http crate
Continued evolution of the Rust language
Gotham is at a point now where everything is back on the table, including the
design choices based on what was stable in Rust at the time we started Gotham in
A call for maintainers
In recent months, development activity in Gotham has decreased. There are two
major reasons that we’ve been less active as maintainers:
Waiting and watching for the changes above to be ready for our adoption; and
Family, paid work, and other commitments that have demanded more of our time.
The second of these points is sufficiently demanding that we don’t have enough
time to maintain Gotham as a serious contender in the Rust web framework arena.
We’d like to “pass the torch” to some new maintainer(s) who are willing to give
Gotham the attention it deserves. If that’s you, please reach out to one of us
via Gitter or email (@bradleybeddoes’ and @smangelsdorf’s email addresses
are in the project’s Git history).
What’s next for Gotham?
Gotham, as it stands, isn’t going away. The repositories, crates and chat
channel will remain. We’ll continue accepting security fixes and releasing patch
versions if necessary, until we determine what’s next.
Feature contributions are still welcome, but may be delayed until a current or
future maintainer has time to consider its relevance, impact on the wider
framework, and the contribution itself.
Beyond that, it’s up to the next maintainer(s) to set the next priorities. We’re
happy to provide our own thoughts on what that should be.
Since the first release of the Gotham web framework in August 2017, we’ve been excitedly watching the community grow and
get involved in the project. Today we’re pleased to announce the release of version 0.2, which includes new
features and refinements identified by the community as well as some from our own wishlist.
Path extractors and query string extractors work via Serde now
Catching application panics to keep the server process alive
Our thanks to everybody involved in the Gotham community by asking questions, providing feedback, and opening issues
and pull requests. Anyone who’d like to get involved should come join us on Gitter
We’ve started adding some issues to the 0.3 roadmap, to get an idea
of what we’d like to tackle next. Some of the noteworthy ones on our list so far:
Async static file serving
A more convenient method of dealing with request bodies (form data being the priority)
Track the evolution of Tokio 0.2 and Futures 0.2, and adapt Gotham to suit the needs of the Rust ecosystem as it is updated for the reformed Tokio
Track the adoption of the http crate by hyper, and change Gotham to use the new types for dealing with HTTP
For the last eight months, we’ve been hard at work on a project that we’re
thrilled to be able to share with the wider Rust community.
We know it as Gotham and today we’re releasing 0.1.
Gotham is a flexible web framework that does not sacrifice
safety, security or speed. The Gotham core team loves many of the elegant
concepts that are found in dynamically typed web application frameworks,
such as Rails/Phoenix/Django and aspire to achieve them with the
type and memory safety guarantees provided by Rust.
Gotham is stability focused. With our release of Gotham 0.1, we’re
compatible with Rust stable and every future release of Gotham will
maintain that contract. Naturally, we build on beta and nightly as well so
if you’re on the bleeding edge Gotham is good to go.
Gotham leverages async extensively thanks to the Tokio project and is
further enhanced by being built directly on top of async
Completing web requests in µs with almost non-existent memory footprints
is still taking some getting used to.
We wanted to get Gotham in the hands of the Rust community early with
regular smaller iterations to follow. The Gotham 0.1 release includes the
Handlers and Controllers
Type Safe Extractors
Middleware and Pipelines
Request and Response helpers
Thoroughly documented code and the beginnings of a Gotham book
There are some important features still to be built and we hope that the
community will help us define even more. Right now our roadmap includes:
Enhancing our Router API with builders/macros to make this much more comfortable for folks used to defining routes in Rails or Phoenix
First class Diesel integration
Async static file serving
Hot reload during development
You can find out more about Gotham at https://gotham.rs. We look forward to
welcoming you into the Gotham community.
Finally, we’d like to say a very sincere thank you to the developers and
communities of every dependency we’ve built Gotham on top of,
including of course, Rust itself. Your work is amazing and we could not have
gotten here without it. We look forward to working with you all in the future.