inko
leptos
inko | leptos | |
---|---|---|
11 | 54 | |
742 | 14,658 | |
3.6% | 1.7% | |
9.4 | 9.8 | |
5 days ago | 8 days ago | |
Rust | Rust | |
Mozilla Public License 2.0 | MIT License |
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.
inko
- A language like C, but with a borrow-checker
- Ask HN: Which language will you try for this year's Advent of Code and why?
-
Inko Programming Language
I have mixed feelings on Rust's syntax, especially around generics, lifetimes, and the `modifier -> keyword` syntax (i.e. `async fn` or `pub fn`). For Inko, I wanted something that's easy to parse by hand, and no context specific parsing (e.g. `QUOTE -> something` being the start of a lifetime in one place, but a char literal in another place).
Another motivator for that is that years ago I worked on Rubinius for a while (an implementation of Ruby), and helped out with a parser for Ruby (https://github.com/whitequark/parser). The Ruby developers really liked changing their already impossible syntax in even more impossible ways on a regular basis, making it a real challenge to provide syntax related tools that support multiple Ruby versions. I wanted to avoid making the same mistake with Inko, hence I'm actively trying to keep the syntax as simple as is reasonable.
As for the specific examples:
- `fn async` means your parser only needs to look for `A | B | fn` in a certain scope, instead of `A | B | fn | async fn`. This cuts down the amount of repetition in the parser. An example is found at https://github.com/inko-lang/inko/blob/8f5ad1e56756fe00325a3..., which parses the body of a class definition.
- Skipping parentheses is directly lifted from Ruby, because I really like it. Older versions took this further by also letting you write `function arg1 arg2`, but I got rid of that to make parsing easier. It's especially nice so you can do things like `if foo.bar.baz? { ... }` instead of `if foo().bar().baz?()`, though I suspect opinions will differ on this :)
- Until recently we did in fact use `::` as a namespace separator, but I changed that to `.` to keep things consistent with the call syntax, and because it removes the need for remembering "Oh for namespaces I need to use ::, but for calls .".
- `[T]` for generics is because most editors automatically insert a closing `]` if you type `[`, but not when you type `<`. If they do, then trying to write `10<20` is annoying because you'd end up with `10<>20`. I also just like the way it looks more. The usual ambiguity issues surrounding `<>` (e.g. what leads to `foo::()` in Rust) doesn't apply to Inko, because we don't allow generics in expressions (i.e. `Array[Int].with_capacity(42)` isn't valid syntax) in the first place.
-
Type inference of local variable based on later operations
Inko supports this in its type checker. The implementation is both surprisingly simple and tricky, and works roughly as follows:
-
The Rust I Wanted Had No Future
Perhaps it's worth looking into Inko? I apologise if I'm shilling my own project a bit too hard here, but reading through the comments it does seem people would be interested in what it's trying to do :)
-
The Rust I wanted had no future
Perhaps you'd be interested in Inko (https://inko-lang.org/). It's obviously not there yet in terms of tooling and what not, but it might scratch an itch for those looking for something a bit like Rust, but easier to use.
Disclaimer: I'm the author of said language :)
-
Does modern implementation use tagged pointers/values?
Inko currently uses tagged pointers, though this is a remnant from when it was still using a VM. I'm working on replacing this with a better solution. In short: for a compiled language I don't think there's really a benefit to using pointer tagging.
-
"Linear style" and the spectrum of zero-cost to memory safety overhead
I think Inko shows this behavior too, where a linear-style program suddenly has zero cost. (Yorick, sanity check me on this?)
-
Thoughts on designing a stack base VM and byte code
For opcodes you can also use a third option: you use a single struct for all opcodes, and size it to support a fixed number of arguments. Most opcodes probably won't need more than 4-5 arguments. If those argument values are small enough (e.g. u16), you don't need that much space. You can find an example of this here, with the Instruction type only taking up 12 bytes.
leptos
-
Migrating a JavaScript frontend to Leptos, a Rust framework
Lots of new frontend frameworks have been built on top of Rust, including Leptos, which happens to be one of the most popular ones. In this guide, we'll highlight why and how to migrate your JavaScript frontend to use the Leptos Rust frontend framework.
-
Rust on Nails
I don't know why OP felt moved to write this weird guide, https://leptos.dev is incredible!
-
Show HN: Flox 1.0 – Open-source dev env as code with Nix
https://github.com/leptos-rs/leptos/blob/main/flake.nix
You want a package? Add it to buildInputs.
You want to search a package: https://search.nixos.org/packages (or use the cli)
you want to test a package before adding it? nix-shell -p or nix shell for example.
Heck, even if you want it more easy, you could write a tool in less than 100 lines that adds packages names to .json/.yaml/.toml, which allows you to parse it using the nix language and a simple cli written with bash functions to add/remove packages if you wanted.
That's why it is hard for me to understand this project as a product, it seems like a wrapper to the most basic things :\
-
Using CRDTs to build collaborative Rust web applications
We use the fantastic Leptos framework for building the frontend. Besides that, we use the leptos-use utilities for connecting to the WebSocket server, serde for serialization, and rand for generating random numbers.
-
Ask HN: Which full stack framework (NextJS, Remix, SvelteKit) would you use?
I'd use https://leptos.dev because you can use a fully typed language (Rust) that is super fast in the backend and also in the frontend (see https://krausest.github.io/js-framework-benchmark/2024/table...)
- Container2wasm: Convert Containers to WASM Blobs
-
What is the best library to write a SCADA-like application for web?
For the web-side, if you'd like to use Rust end-to-end we've had the best experience with Leptos: https://leptos.dev/
-
Question: how good is Rust for web development?
I'd suggest https://leptos.dev/ is worth a look. I haven't used it yet, but plan to soon.
-
RustGPT: ChatGPT UI Built with Rust, Htmx, SQLite
I think a lot of us reach for Jinja-style templates so it feels a little more like we're writing bare HTML. But they're of course still just templates, and they need a build step before they become valid HTML.
So it's true, if you're willing to use a DSL embedded in your server language (like JSX), then you'll have the full language tooling available to you. And this probably isn't giving up much over language-specific templates.
A JSX-equivalent for the Rust server-side rendering world would probably be maud [1] or leptops [2].
[1] https://github.com/lambda-fairy/maud
[2] https://github.com/leptos-rs/leptos
-
Trying out Leptos: Fine-grained Reactive Framework for Rust
I wanted to deploy the app serverlessly, opting for Deno Deploy hosting. The JS fetch example and the leptos-deno examples were handy to get me going.
What are some alternatives?
llrl - An experimental Lisp-like programming language
dioxus - Fullstack GUI library for web, desktop, mobile, and more.
rust-langdev - Language development libraries for Rust
yew - Rust / Wasm framework for creating reliable and efficient web applications
lltz - LLTZ: Compiler from MLIR to Michelson
tauri - Build smaller, faster, and more secure desktop applications with a web frontend.
brainfk-rs - Compiles brainfuck to wasm!!
Svelte - Cybernetically enhanced web apps
logic - Logic backend implementation for Robot Rumble
sycamore - A library for creating reactive web apps in Rust and WebAssembly
parser - A Ruby parser.
actix-web - Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust.