rust-analyzer VS rust

Compare rust-analyzer vs rust and see what are their differences.

rust-analyzer

A Rust compiler front-end for IDEs [Moved to: https://github.com/rust-lang/rust-analyzer] (by rust-analyzer)

rust

Empowering everyone to build reliable and efficient software. (by rust-lang)
Our great sponsors
  • InfluxDB - Power Real-Time Data Analytics at Scale
  • WorkOS - The modern identity platform for B2B SaaS
  • SaaSHub - Software Alternatives and Reviews
rust-analyzer rust
207 2674
9,320 91,922
- 2.8%
10.0 10.0
almost 2 years ago 3 days ago
Rust Rust
GNU General Public License v3.0 or later GNU General Public License v3.0 or later
The number of mentions indicates the total number of mentions that we've tracked plus the number of user suggested alternatives.
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.

rust-analyzer

Posts with mentions or reviews of rust-analyzer. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2023-01-17.
  • rust-analyzer changelog #164
    3 projects | /r/rust | 17 Jan 2023
    I would like changes like https://github.com/rust-analyzer/rust-analyzer/pull/13799 to be listed in 'Breaking Changes' category, to приманка draw the users' attention.
  • Mun v0.4.0 released
    4 projects | /r/rust_gamedev | 13 Dec 2022
    For those of you who haven’t heard of Mun before, Mun is an embeddable programming language empowering creation through iteration. The idea to create Mun originated out of frustration with the Lua dynamic scripting language and a desire to have similar hot reloading functionality available in Rust. As such, it’s not a direct competitor with Rust, but instead is intended to be used with Rust (or C/C++) as a host/embedded language pairing. Actually, Mun is completely written in Rust, building on similar crates as rust-analyzer and rustc. Its key features include:
  • rust-analyzer changelog #159
    2 projects | /r/rust | 12 Dec 2022
    #13728 upgrade chalk to make solver fuel work again (works around most trait solving hangs).
  • Does Rust need proc-macros 2.0?
    2 projects | /r/rust | 27 Jul 2022
    Rust-analyzer has a good overview: https://github.com/rust-analyzer/rust-analyzer/blob/master/docs/dev/syntax.md
  • rust-analyzer changelog #134
    7 projects | /r/rust | 20 Jun 2022
    #12517 (first contribution) fix completion for methods in trait generated by macro.
    7 projects | /r/rust | 20 Jun 2022
  • LSP Rust Analyzer keeps telling me `Error NO_RESULT_CALLBACK_FOUND`
    3 projects | /r/neovim | 12 Jun 2022
    -- all the opts to send to nvim-lspconfig -- these override the defaults set by rust-tools.nvim -- see https://github.com/neovim/nvim-lspconfig/blob/master/doc/server_configurations.md#rust_analyzer server = { -- on_attach is a callback called when the language server attachs to the buffer -- on_attach = on_attach, settings = { -- to enable rust-analyzer settings visit: -- https://github.com/rust-analyzer/rust-analyzer/blob/master/docs/user/generated_config.adoc ["rust-analyzer"] = { -- enable clippy on save checkOnSave = { command = "clippy" }, assist = { importGranularity = "module", importPrefix = "self", }, cargo = { loadOutDirsFromCheck = true }, procMacro = { enable = true }, } } },
  • rust-analyzer changelog #130
    2 projects | /r/rust | 23 May 2022
    #12349 publish universal VSIX to make Code happy.
    2 projects | /r/rust | 23 May 2022
    Big fan of #12263!
  • Anyone have autocomplete working with rust-tools, nvm-cmp, etc.?
    6 projects | /r/neovim | 14 Apr 2022
    -- Provide some indication that rust-analyzer is busy! local lsp_status = require('lsp-status') lsp_status.register_progress() -- Basic rust/lsp/cmp settings from https://sharksforarms.dev/posts/neovim-rust/ local nvim_lsp = require('lspconfig') local opts = { tools = { -- rust-tools options autoSetHints = true, hover_with_actions = true, inlay_hints = { show_parameter_hints = false, parameter_hints_prefix = "", other_hints_prefix = "=> ", }, }, -- all the opts to send to nvim-lspconfig -- these override the defaults set by rust-tools.nvim -- see https://github.com/neovim/nvim-lspconfig/blob/master/doc/server_configurations.md#rust_analyzer server = { -- on_attach is a callback called when the language server attachs to the buffer on_attach = lsp_status.on_attach, capabilities = lsp_status.capabilities, settings = { -- to enable rust-analyzer settings visit: -- https://github.com/rust-analyzer/rust-analyzer/blob/master/docs/user/generated_config.adoc -- and more: https://github.com/simrat39/rust-tools.nvim/wiki/Server-Configuration-Schema ["rust-analyzer"] = { -- enable clippy on save checkOnSave = { command = "clippy" }, } } }, } require('rust-tools').setup(opts) -- Setup Completion -- See https://github.com/hrsh7th/nvim-cmp#basic-configuration -- Used for super-tab functionality local has_words_before = function() local line, col = unpack(vim.api.nvim_win_get_cursor(0)) return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match("%s") == nil end local feedkey = function(key, mode) vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes(key, true, true, true), mode, true) end local lspkind = require('lspkind') local cmp = require'cmp' cmp.setup({ completion = { autocomplete = true }, -- Enable LSP snippets snippet = { expand = function(args) vim.fn["vsnip#anonymous"](args.body) end, }, mapping = { [''] = cmp.mapping.select_prev_item(), [''] = cmp.mapping.select_next_item(), [''] = cmp.mapping.scroll_docs(-4), [''] = cmp.mapping.scroll_docs(4), [''] = cmp.mapping.complete(), [''] = cmp.mapping.close(), [''] = cmp.mapping.confirm({ behavior = cmp.ConfirmBehavior.Insert, select = true, }), -- Add tab support [""] = cmp.mapping(function(fallback) if cmp.visible() then cmp.select_next_item() elseif vim.fn["vsnip#available"](1) == 1 then feedkey("(vsnip-expand-or-jump)", "") elseif has_words_before() then cmp.complete() else fallback() -- The fallback function sends a already mapped key. In this case, it's probably ``. end end, { "i", "s" }), [""] = cmp.mapping(function() if cmp.visible() then cmp.select_prev_item() elseif vim.fn["vsnip#jumpable"](-1) == 1 then feedkey("(vsnip-jump-prev)", "") end end, { "i", "s" }), }, -- Installed sources sources = { { name = 'nvim_lsp' }, --, trigger_characters={'.', ":"} }, { name = 'vsnip' }, { name = 'path' }, { name = 'buffer' }, { name = 'nvim_lsp_signature_help' }, { name = 'nvim_lsp_document_symbol' }, }, -- Fancy symbols formatting = { format = lspkind.cmp_format({ mode = 'symbol_text', -- show both symbol & text for now maxwidth = 50, -- prevent the popup from showing more than provided characters (e.g 50 will not show more than 50 characters) -- The function below will be called before any actual modifications from lspkind -- so that you can provide more controls on popup customization. (See [#30](https://github.com/onsails/lspkind-nvim/pull/30)) --before = function (entry, vim_item) --... --return vim_item --end }) }, completion = { autocomplete = true }, })

rust

Posts with mentions or reviews of rust. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2024-03-25.
  • What Are Const Generics and How Are They Used in Rust?
    3 projects | dev.to | 25 Mar 2024
    The above Assert<{N % 2 == 1}> requires #![feature(generic_const_exprs)] and the nightly toolchain. See https://github.com/rust-lang/rust/issues/76560 for more info.
  • Algorithms for Modern Hardware
    2 projects | news.ycombinator.com | 13 Mar 2024
    There’s also other reasons. For example, take binary search:

    * prefetch + cmov. These should be part of the STL but languages and compilers struggle to emit the cmov properly (Rust’s been broken for 6 years: https://github.com/rust-lang/rust/issues/53823). Prefetch is an interesting one because while you do optimize the binary search in a micro benchmark, you’re potentially putting extra pressure on the cache with “garbage” data which means it’s a greedy optimization that might hurt surrounding code. Probably should have separate implementations as binary search isn’t necessarily always in the hot path.

    * Eytzinger layout has additional limitations that are often not discussed when pointing out “hey this is faster”. Adding elements is non-trivial since you first have to add + sort (as you would for binary search) and then rebuild a new parallel eytzinger layout from scratch (i.e. you’d have it be an index of pointers rather than the values themselves which adds memory overhead + indirection for the comparisons). You can’t find the “insertion” position for non-existent elements which means it can’t be used for std::lower_bound (i.e. if the element doesn’t exist, you just get None back instead of Err(position where it can be slotted in to maintain order).

    Basically, optimizations can sometimes rely on changing the problem domain so that you can trade off features of the algorithm against the runtime. These kinds of algorithms can be a bad fit for a standard library which aims to be a toolbox of “good enough” algorithms and data structures for problems that appear very very frequently. Or they could be part of the standard library toolkit just under a different name but you also have to balance that against maintenance concerns.

  • Rust: Actix-web and Daily Logging
    3 projects | dev.to | 13 Mar 2024
  • Groovy 🎷 Cheat Sheet - 01 Say "Hello" from Groovy
    7 projects | dev.to | 7 Mar 2024
    But that said, - and again I might be a bit biased - Groovy is too slow for me! I compared it to Rust in this LinkedIn post and it was waaaaay slow. Keep in mind that subjectively comparing programming languages might be a tricky business. But at the end, it will be up to your use case/project to prefer a language over the other.
  • Top Paying Programming Technologies 2024
    19 projects | dev.to | 6 Mar 2024
    13. Rust - $87,012
  • Dada, an Experiement by the Creators of Rust
    9 projects | news.ycombinator.com | 6 Mar 2024
    Yes, actually.

    https://github.com/rust-lang/rust/blob/d0ea1d767925d53b2230e...

    Limited to the rust codebase itself, but I'm sure the developers would force it on everyone else if they thought they could get away with it.

  • 7 Programming Languages Every Cloud Engineer Should Know in 2024!
    4 projects | dev.to | 5 Mar 2024
    Rust is gaining momentum in the cloud computing domain due to its emphasis on safety, speed, and concurrency without a garbage collector. These features make Rust an appealing choice for cloud engineers looking to develop high-performance, secure, and reliable cloud services and infrastructure. Rust's memory safety guarantees and efficient compilation to machine code position it as an ideal language for system-level and embedded applications in cloud environments, where performance and security are paramount.
  • Borrow Checking Without Lifetimes
    4 projects | news.ycombinator.com | 4 Mar 2024
    > I'm not sure what's neutered about Rust's current plans for generators

    They're neutered because they can't suspend and transfer control to a function other than the one that called them ("Note also that "coroutines" here are really "semicoroutines" since they can only yield back to their caller." https://lang-team.rust-lang.org/design_notes/general_corouti...) and you can't pass values into resume and get them out from the yield statement in the coroutine (https://github.com/rust-lang/rust/issues/43122#issuecomment-...).

    > and they aren't separate from async, they're the foundation that async desugars to.

    Yeah I just looked it up again and I don't know why I had it in my head that they were separate, you're correct, they are the same thing under the hood, so honestly that eliminates my biggest problem with them.

    > 'm also not sure what your objection is to Polonius, which, so far, is still just a strictly more permissive version of the borrow checker, with nothing new to learn on the user end.

    The entire model is different under the hood, though, since it switches from lifetimes+borrows to loans, and so in order to fully understand its behavior the user really would have to change their mental model, and as I said above I'm a huge fan of the lifetimes model and less so of the loan model. I just feel like it's much more natural to treat the ownership of a memory object and therefore amount of time in your code that object lives as the fixed point, and borrows as wrong for outliving what they refer to, then to treat borrows as the fixed point, and objects as wrong for going out of scope and being dropped before the borrow ends, because the fundamental memory management model of Rust is single ownership of objects, moves, and scope based RAII via Drop, so the lifetime of an object kind of is the more basic building block of the memory model, with borrows sort of conceptually orbiting around that and naturally being adjusted to fit that, with the checker being a way to force you to adhere to that. The loan based way of thinking would make more sense for an ARC-based language where references actually are more basic because objects really do only live for as long as there are references to them.

    4 projects | news.ycombinator.com | 4 Mar 2024
    > you can't pass values into resume and get them out from the yield statement in the coroutine

    I think that the linked comment is out of date, and that this is supported now (hard to tell because it hasn't been close enough to stabilization to be properly documented): https://github.com/rust-lang/rust/pull/68524

    As for Polonius changing the underlying mental model, I think this is a natural progression. Rust 1.0 tried to present a simple lexical model of borrowing, and then enough people complained that it has long since replaced the simple model with non-lexical lifetimes in order to trade simplicity for "do what I mean". And since it's not allowed to break any old code, if you want to continue treating borrowing like it has the previous model then that shouldn't present any difficulties.

  • Why do we need for an Undefined Behavior Annex to C++
    3 projects | news.ycombinator.com | 1 Mar 2024
    I don't see where those methods are getting called from a Unix signal handler but the code is complex enough that it's easy to miss, especially perusing through github instead of vscode.

    AFAICT those methods are called from `guard::current`. In turn, `guard::current` is used to initialize TLS data when a thread is spawned before a signal is generated (& right after the signal handler is installed): https://github.com/rust-lang/rust/blob/26907374b9478d84d766a...

    It doesn't look like there's any UB behavior being relied upon but I could very easily be misreading. If I missed it, please give me some more pointers cause this should be a github issue if it's the case - calling non async-safe methods from a signal handler typically can result in a deadlock which is no bueno.

What are some alternatives?

When comparing rust-analyzer and rust you can also consider the following projects:

carbon-lang - Carbon Language's main repository: documents, design, implementation, and related tools. (NOTE: Carbon Language is experimental; see README)

zig - General-purpose programming language and toolchain for maintaining robust, optimal, and reusable software.

vscode-rust - Rust extension for Visual Studio Code

Nim - Nim is a statically typed compiled systems programming language. It combines successful concepts from mature languages like Python, Ada and Modula. Its design focuses on efficiency, expressiveness, and elegance (in that order of priority).

Odin - Odin Programming Language

Elixir - Elixir is a dynamic, functional language for building scalable and maintainable applications

Clippy - A bunch of lints to catch common mistakes and improve your Rust code. Book: https://doc.rust-lang.org/clippy/

intellij-rust - Rust plugin for the IntelliJ Platform

rustfmt - Format Rust code

Rustup - The Rust toolchain installer

eglot - A client for Language Server Protocol servers

coc.nvim - Nodejs extension host for vim & neovim, load extensions like VSCode and host language servers.