{"id":15030875,"url":"https://github.com/rust-lang/rust-roadmap-2017","last_synced_at":"2025-10-04T05:31:15.400Z","repository":{"id":65977413,"uuid":"73123625","full_name":"rust-lang/rust-roadmap-2017","owner":"rust-lang","description":"Tracking Rust's roadmap","archived":true,"fork":false,"pushed_at":"2017-04-12T09:43:19.000Z","size":4,"stargazers_count":215,"open_issues_count":25,"forks_count":12,"subscribers_count":116,"default_branch":"master","last_synced_at":"2024-09-29T23:01:28.744Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":"","language":null,"has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/rust-lang.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null}},"created_at":"2016-11-07T21:43:57.000Z","updated_at":"2024-09-11T15:37:55.000Z","dependencies_parsed_at":"2023-02-19T18:20:15.027Z","dependency_job_id":null,"html_url":"https://github.com/rust-lang/rust-roadmap-2017","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/rust-lang%2Frust-roadmap-2017","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/rust-lang%2Frust-roadmap-2017/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/rust-lang%2Frust-roadmap-2017/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/rust-lang%2Frust-roadmap-2017/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/rust-lang","download_url":"https://codeload.github.com/rust-lang/rust-roadmap-2017/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":235222543,"owners_count":18955327,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2024-09-24T20:14:26.148Z","updated_at":"2025-10-04T05:31:10.135Z","avatar_url":"https://github.com/rust-lang.png","language":null,"funding_links":[],"categories":[],"sub_categories":[],"readme":"## Rust 2017 Roadmap\n\nAs part of [RFC 1728](https://github.com/rust-lang/rfcs/pull/1728), each year\nthe Rust community puts together a *roadmap* laying out a vision for\nimprovements to Rust over the course of the year. The 2017 roadmap was decided\nin [RFC 1774](https://github.com/rust-lang/rfcs/pull/1774).\n\nThe issues in this repository track the progress on our 2017 roadmap.\n\n**Only Rust subteam members should create new issues in this repo**. If you\nbelieve a project should be added within the tracker, please leave a comment on\nthe appropriate \"parent\" issue, i.e. one of the issues linked below. And in\ngeneral, feel free to use comments to ask questions, pitch ideas, or mention\nupdates that need to be made!\n\nThere are issues for each of the vision statements:\n\n* [Rust should have a lower learning curve](https://github.com/aturon/rust-roadmap/issues/3)\n* [Rust should have a pleasant edit-compile-debug cycle](https://github.com/aturon/rust-roadmap/issues/1)\n* [Rust should provide a solid, but basic IDE experience](https://github.com/aturon/rust-roadmap/issues/2)\n* [Rust should provide easy access to high quality crates](https://github.com/aturon/rust-roadmap/issues/9)\n* [Rust should be well-equipped for writing robust, high-scale servers](https://github.com/aturon/rust-roadmap/issues/10)\n* [Rust should have 1.0-level crates for essential tasks](https://github.com/aturon/rust-roadmap/issues/11)\n* [Rust should integrate easily into large build systems](https://github.com/aturon/rust-roadmap/issues/12)\n* [Rust's community should provide mentoring at all levels](https://github.com/aturon/rust-roadmap/issues/13)\n\nand for our two areas of exploration:\n\n* [Integration with other languages, running the gamut from C to JavaScript](https://github.com/aturon/rust-roadmap/issues/14)\n* [Usage in resource-constrained environments](https://github.com/aturon/rust-roadmap/issues/15)\n\nEach of the above issues link to a number of other *project* issues, which give\npoints of contact and other information about the status of specific projects\nworking to achieve one of our goals. You can see the list of all projects [here](https://github.com/aturon/rust-roadmap/issues?q=is%3Aissue+is%3Aopen+label%3AProject).\n\nFinally, each subteam has a dedicated roadmap issue, spelling out areas of\nactivity beyond those included in the formal Rust roadmap:\n\n- [Lang team](https://github.com/aturon/rust-roadmap/issues/18)\n- [Libs team](https://github.com/aturon/rust-roadmap/issues/19)\n- [Compiler team](https://github.com/aturon/rust-roadmap/issues/21)\n- [Community team](https://github.com/aturon/rust-roadmap/issues/22)\n- [Docs team](https://github.com/aturon/rust-roadmap/issues/20)\n- [Tools team](https://github.com/aturon/rust-roadmap/issues/23)\n\n## Roadmap rationale\n\nThe full rationale for the roadmap is spelled out in\n[RFC 1774](https://github.com/rust-lang/rfcs/pull/1774), but we'll recap the\nhigh-level framing here.\n\nThere's no end of possible improvements to Rust—so what do we use to guide our\nthinking?\n\nThe core team has tended to view our strategy not in terms of particular features or\naesthetic goals, but instead in terms of **making Rust successful while staying\ntrue to its core values**. This basic sentiment underlies much of the proposed\nroadmap, so let's unpack it a bit.\n\n### Making Rust successful\n\n#### The measure of success\n\nWhat does it mean for Rust to be successful? There are a lot of good answers to\nthis question, a lot of different things that draw people to use or contribute\nto Rust. But regardless of our *personal* values, there's at least one clear\nmeasure for Rust's broad success: **people should be using Rust in\nproduction and reaping clear benefits from doing so**.\n\n- Production use matters for the obvious reason: it grows the set of\n  stakeholders with potential to invest in the language and ecosystem. To\n  deliver on that potential, Rust needs to be part of the backbone of some major\n  products.\n\n- Production use measures our *design* success; it's the ultimate reality\n  check. Rust takes a unique stance on a number of tradeoffs, which we believe\n  to position it well for writing fast and reliable software. The real test of\n  those beliefs is people using Rust to build large, production systems, on\n  which they're betting time and money.\n\n- The *kind* of production use matters. For Rust to truly be a success, there\n  should be clear-cut reasons people are employing it rather than another\n  language. Rust needs to provide crisp, standout benefits to the organizations\n  using it.\n\nThe idea here is *not* about \"taking over the world\" with Rust; it's not about\nmarket share for the sake of market share. But if Rust is truly delivering a\nvaluable new way of programming, we should be seeing that benefit in \"the real\nworld\", in production uses that are significant enough to help sustain Rust's\ndevelopment.\n\nThat's not to say we should expect to see this usage *immediately*; there's a\nlong pipeline for technology adoption, so the effects of our work can take a\nwhile to appear. The framing here is about our long-term aims. We should be\nmaking investments in Rust today that will position it well for this kind of\nsuccess in the future.\n\n#### The obstacles to success\n\nAt this point, we have a fair amount of data about how Rust is reaching its\naudience, through the [2016 survey], informal conversations, and explicit\noutreach to (pre-)production shops (writeup coming soon). The data from the\nsurvey is generally corroborated by these other venues, so let's focus on that.\n\n[2016 survey]: https://blog.rust-lang.org/2016/06/30/State-of-Rust-Survey-2016.html\n\nWe asked both current and potential users what most stands in the way of their\nusing Rust, and got some pretty clear answers:\n\n- 1 in 4: learning curve\n- 1 in 7: lack of libraries\n- 1 in 9: general “maturity” concerns\n- 1 in 19: lack of IDEs (1 in 4 non-users)\n- 1 in 20: compiler performance\n\nNone of these obstacles is directly about the core language or `std`; people are\ngenerally happy with what the language offers today. Instead, the connecting\ntheme is *productivity*—how quickly can I start writing real code? bring up a\nteam? prototype and iterate? debug my code? And so on.\n\nIn other words, our primary challenge isn't making Rust \"better\" in the\nabstract; it's making people *productive* with Rust. The need is most pronounced\nin the early stages of Rust learning, where we risk losing a large pool of\ninterested people if we can't get them over the hump. Evidence from the survey\nand elsewhere suggests that once people do get over the initial learning curve,\nthey tend to stick around.\n\nSo how do we pull it off?\n\n#### Core values\n\nPart of what makes Rust so exciting is that it attempts to eliminate some\nseemingly fundamental tradeoffs. The central such tradeoff is between safety\nand speed. Rust strives for\n\n- uncompromising reliability\n- uncompromising performance\n\nand delivers on this goal largely thanks to its fundamental concept of\nownership.\n\nBut there's a problem: at first glance, \"productivity\" and \"learnability\" may\nseem at odds with Rust's core goals. It's common to hear the refrain that\n\"fighting with the borrow checker\" is a rite of passage for Rustaceans. Or that\nremoving papercuts would mean glossing over safety holes or performance cliffs.\n\nTo be sure, there are tradeoffs here. But as above, if there's one thing the\nRust community knows how to do, it's bending the curve around tradeoffs—memory\nsafety without garbage collection, concurrency without data races, and all the\nrest. We have many examples in the language where we've managed to make a\nfeature pleasant to use, while also providing maximum performance and\nsafety—closures are a particularly good example, but there are\n[others](https://internals.rust-lang.org/t/roadmap-2017-productivity-learning-curve-and-expressiveness/4097).\n\nAnd of course, beyond the core language, \"productivity\" also depends a lot on\ntooling and the ecosystem. Cargo is one example where Rust's tooling provides a\nhuge productivity boost, and we've been working hard on other aspects of\ntooling, like the\n[compiler's error messages](https://blog.rust-lang.org/2016/08/10/Shape-of-errors-to-come.html),\nthat likewise have a big impact on productivity. There's so much more we can be\ndoing in this space.\n\nIn short, **productivity should be a core value of Rust**. By the end of 2017,\nlet's try to earn the slogan:\n\n- Rust: fast, reliable, productive—pick three.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Frust-lang%2Frust-roadmap-2017","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Frust-lang%2Frust-roadmap-2017","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Frust-lang%2Frust-roadmap-2017/lists"}