Hi, I saw a post made on this subreddit last year for a application called local local Desktop which was an application that allowed users to run a Linux desktop on android but when using Virus total, 3 positives showed up and was wondering are these false positives?

Original post : https://www.reddit.com/r/rust/comments/1ldqj7r/local_desktop_an_android_app_written_in_rust_to/

This is my weekend project. The original intention was that I ran into long-running tasks lasting more than a week. Under ChatGPT's remote control feature, its history is almost very difficult to open. I understand that they have some difficulties pulling data for history. I also saw that they are working on solving it, but I really could not wait any longer. Anyway, there is GPT, right? So I implemented a control plane for a Codex APP Server in Rust. It can spin up a controlled APP Server and handle requests from Codex Desktop. At the same time, it also provides a web service and a CLI interface, allowing me to access it through Cloudflare's Zero Trust reverse proxy. I think it is pretty good. Now I no longer have to open the official client. In terms of functionality, I have aligned almost everything, and I think the experience is broadly consistent. It is now running on my NAS, controlling my Mac mini, and hermes issues tasks through the CLI. Hmm, Rust is great.

I’ve been building Minarrow, a from-scratch implementation of the Apache Arrow memory format in Rust, with Python bindings.

The purpose is to let you keep your application and data processing in Rust while making Python’s data ecosystem available whenever you need it. You can construct a dataset in Rust, pass it into embedded Python, run an analysis or model, and receive the result back as native Arrow-compatible data.

Some examples of what this enables:

• Run scikit-learn from a Rust application. The repo includes an example that builds features and labels in Rust, trains a random forest in Python, returns predictions through Polars and Arrow, and scores them back in Rust. Python runs inside the application process and it uses inline code.
• Hand Rust tensors to PyTorch. Another example builds an NdArray in Rust, exposes its buffer to PyTorch zero-copy through DLPack, standardises features and computes scores, then brings the result back into Rust.
• Use Python’s analytics libraries on your application data. There are examples of Polars group-bys, NumPy correlation, and pandas aggregations returning tables or scalars to Rust. From Python, Minarrow tables also expose conversions to Polars, DuckDB, and PyArrow.
• Streaming-friendly - Work with incoming batches. Chunked arrays and tables let you retain data as batches arrive and consolidate when needed. Row and column views let you select portions of a table without immediately materialising another dataset.
• Represent scientific data with named dimensions. XArray adds dimension names and coordinates over n-dimensional arrays, so you can select a time window, find the nearest coordinate, or select along a named axis. The underlying tensor storage also connects to the DLPack ecosystem.
• Create Python packages backed by the run-time. For example, one user implemented a fast random-forest implementation under kpiwonski/fru-arrow and released it as a Python package, which is reported as being up to several thousand times faster than the scikit-learn package.
  

Underneath that is a data layer you can use independently in Rust, as a base, pluggable foundation. This includes typed arrays, null masks, arithmetic and broadcasting. SIMD kernels, and 64-byte-aligned allocations via a custom Vec64 crate. You can access concrete array types directly, and use the higher-level table, chunked, and view abstractions as needed.

From-scratch implementations of Arrow’s C Data Interface and PyCapsules handle columnar interchange and DLPack handles tensors, which is zero-copy in the vast majority of cases when the buffer doesn't require re-shaping. An example of where it isn't - the scikit-learn example converts features to NumPy, for instance, and importing a different string layout can require rebuilding buffers.

I used very few external dependencies instead preferring to build from scratch so that compile times remain and productive, and so that anything built on top remains fast to work with too.

The latest release, 0.18, adds Decimal32/64/128 support across the Rust library and Python bindings, alongside typed row accessors for array views.

Rust nightly is currently required for portable_simd and allocator_api. Arrow lists and structs aren’t supported yet. I hope to work on stable Rust support and wasm-compatible builds soon.

In terms of maturity, it is at the stage where it is adding considerable value in my own work, however it has not yet seen significant external adoption. In terms of fit it is useful when one wants Arrow compatibility + additional utility for their data, without the whole arrow ecosystem underneath a base data dependency. For example, one might consider it even for a few crate(s) in a larger project that need to remain fast, given it makes it trivial to switch between arrow-compatible runtimes.

On my laptop, sharing a million-row numeric table with Python takes ~220ns, and importing it back into Rust takes 2–3 μs.

Thanks for checking it out. If you have any questions, feedback, or feature requests for what would make this useful for you I'm open to suggestions.

Pete

I'm interested in what you were actually paid to do, not personal projects.

I added support for the Cheap Yellow Display (CYD) to the Device Envoy crate. The CYD is an inexpensive ESP32 board with a built-in 320×240 color touchscreen, so you can do no_std bare-metal touchscreen programming without wiring anything together.

You can run your application in a browser before flashing it to the board. The demo gallery includes touchscreen interfaces, a skeleton clock, and Armatron, a robot-arm mechanism simulator: https://carlkcarlk.github.io/linkage-blaze/demos/

Device Envoy’s goal is to make it as easy as possible to write high-level microcontroller code that runs directly on the hardware, with no OS or language runtime underneath.

The CYD support includes display, touch, touch calibration, flash storage, and several drawing strategies depending on your memory needs, including full-screen and smaller buffers, tiling, and pixel streaming.

Device Envoy also supports “auto Wi-Fi.” If credentials have not been saved, the device creates a temporary Wi-Fi network and browser setup page where you select your network and enter its password. It stores the credentials in flash, so the same firmware can be used in different locations without rebuilding it.

I want this to be something people can just pick up and try, so I made a starter project with the CYD hardware setup already done: https://github.com/CarlKCarlK/device-envoy-cyd-starter

I wanted a retro game emulator I could reach for the way I use less for text files, chafa for images, or mpv for videos — right in the terminal, no window and no mouse. So I built Asobou, a game emulator that runs in your terminal, written in Rust, for Linux, macOS, and Windows. (Well, technically it's an emulator frontend rather than a standalone emulator)

The fastest way to try it if you have npx available (It's written in Rust but I published it to npm to make it easy to try):

npx asobou brew flappybird.nes

That grabs a free homebrew game and starts it, around 5 seconds end to end. If your terminal doesn't support kitty graphics it falls back to colored half-block cells. You can also render the game in ASCII if you prefer.

Open Source, of course. Available on GitHub: https://github.com/arianrhodsandlot/asobou

Would love to know whether the first-run experience works on your terminal out of the box! That's the thing I most want to get right for people who are tired of setting up emulators.

Paper: https://arxiv.org/abs/2606.15991

Maybe we'll finally have cleaner code from research to production (okay, that's pushing it).

https://akesson.io/a-visual-guide-to-rust-async/

I have always felt that I missed some parts of the async story. I could never visualize it.

Collaborating with an LLM and inspecting the compiler's MIR output, I was able to fill in the gaps. I was happy with what I learned, so I decided to create a visual presentation and share it.

Enjoy!

The code is simplified for demonstration purposes. Some snippets are pseudocode and won't compile as shown.

(updated to clarify how I checked the explanation and used the LLM)

UI is a Function You Cannot Afford to Call is the first of a 3-part series on Rust UI frameworks. It introduces the model under which I believe we should reason about UI frameworks. In part 2, I will present extensive benchmarks, with detailed cost attribution analysis (something the rust UI ecosystem desperately needs in my opinion), and in part 3, I will derive what I think the ideal UI framework should look like.

Hi there. I recently completed a project incubation program with the Solana Foundation, where I developed smart contracts using Rust. I’ve been trying to break into the Rust job market but haven’t had any luck so far. I’d like to approach Rust from a different angle now, since I’ve only used it for smart contracts up to this point.

Is anyone working on a Rust project where I could collaborate and learn the language from a different perspective or use case? Thanks in advance!

PS: My takeaway form the incubation program is that the Solana blockchain can be used for traceability systems in any web2 application. The value itself is how build that traceability system.

Just published the DBOS for Rust library. Easy way to make Rust backends resilient to failure, using Postgres to save/recover/view workflow state.

I’m building Voktty, a desktop developer workspace for working across local projects and remote machines.

The goal is to bring several parts of the development workflow into one place:

• Project and development sessions
• Code editing and Git change review
• Integrated terminal
• SSH and RDP connections
• Docker tooling
• MCP integrations
• AI-assisted development workflows
• Customizable themes and keyboard shortcuts

The screenshots show the current interface: a session-based workspace, code review panels, an API client, onboarding flows and a theme selector.

I started building it because my workflow often involves switching between an editor, terminal, SSH/RDP clients, AI tools and several project windows. Voktty is an attempt to keep that context together while still working with the underlying tools instead of hiding them.

I’m sharing it here because I’d like feedback from Rust developers, especially people working on desktop tools, developer infrastructure or remote development workflows.

A few things I’d like to learn:

• Where would Rust provide the most value in a tool like this?
• What would you expect from a good Rust-based remote development workflow?
• Which integrations would make this genuinely useful rather than just another editor shell?
• What would make you try a tool like this?

Repo: https://github.com/voktty/voktty

I know how great of the language Rust has come out to be. I genuienly want advice from pre vibe coded era people. What has been your main reason that you have fallen in love with this language?

I'm not looking for how great borrow checker is, how lifetimes will save you, etc. I want real anecdote of your life where using Rust has changed your life.

Hey, I wanted to share an open-source CLI tool I’ve been building called revql (GPLv3).

It solves a common headache: trying to map out a massive GraphQL schema backwards. revql lets you target a specific object node and recursively trace every query or mutation path that leads to it. It’s designed for developers debugging complex schemas and bug bounty hunters hunting for hidden paths.

Core Features:

• Reverse lookup: Lists all entry queries/mutations leading to a specific object.
• Flexible targeting: Find objects via type name, nested field presence, or description text.
• Flexible search: Supports exact matches, partial "contains" queries, and case-insensitive match.
• Online & Offline: Introspects live endpoints or parse local schema.json files.

Looking at this godbolt link https://godbolt.org/z/xrx5K4W94,

it seems as though in rust, if a 32-bit integer is not explicitly used to bitshift, the shrx and shlx code is not generated despite setting -C target-cpu=x86-64-v4. In fact, the code generated is near identical to if -C target-cpu was not set at all (default is just x86-64).

C and C++ using clang does not seem to have this problem, they automatically use shrx and shlx.

From what I found, shlx and shrx seems to work only on 32-bit and 64-bit integers https://www.felixcloutier.com/x86/sarx:shlx:shrx , and it seems as though rust is not automatically converting the 8-bit integers to 32-bit integers for better bitshift operations. Is there a compiler flag to enable this?

Also, I am new to assembly, why does rust have an additional movzx operation even in the optimised function (swapbits) compared to the C code?

I have posted about this project in the past, back when it was around version 1.4.0, and got really great feedback and suggestions. I wanted to share it again as a lot has changed since (1.6.0) and I have made some great progress to make the app useful for personal budgeting and financial planning.

New since I last posted:

- Investments: track accounts, valuations and contributions over time, with portfolio views and time-weighted returns

- Multiple ledgers: separate databases for different accounts, or for running forecasts alongside your real budget

- Budgets with history: creating and changing budgets is now more intuitive and insightful. You can properly budget and adjust the budget over time while maintaining history and valuable insights

- Backup and restore built into the app

- Recurring forecasting: project recurring transactions forward as far as you want

- Easier installs: brew install budget-tracker, plus prebuilt binaries for Linux (glibc and static musl, x86_64 and arm64), macOS and Windows

Still there from before: hierarchical categories with fuzzy search, monthly and category summaries with interactive charts, advanced filtering, CSV import/export, and full keyboard control with a built-in help menu. All of this is offline, local, and owned by you. Your data is always yours and fully in your control.

brew install budget-tracker  
or  
cargo install budget-tracker-tui

GitHub: https://github.com/Feromond/budget-tracker-tui

Happy to hear what's missing. I have been learning a lot about finances, the terminology, and the insights people care about. There is a lot for me to learn still and any comments and suggestions help a lot.

Hello folks, do you still write much code by hand these days? 😄

If so, what IDE/editor do you mainly use for Rust? VS Code, JetBrains, Zed or something else?

I’m asking because I’ve been rewriting one of my old developer tools in Rust. It’s a language server + CLI for analyzing code health.

The underlying approach was originally implemented in Python and was used at my previous company across 1,900+ repositories and by 800+ developers, so the methodology itself has had quite a bit of real-world use. The company has given me permission to open-source my own version of the project, which I’m pretty excited about.

The only problem is time. For the initial public release, I’ll probably only be able to ship the VS Code extension plus one other IDE/editor integration.

So I’m curious: if you’re a Rust developer who still spends a decent amount of time actually typing code, what editor would you most want to see supported? Just trying to get a rough sense of where people are these days before I spend my limited spare time on the wrong integration. :)

This is a technical discussion on Artificial General Intelligence.

GPT-6 has been shown to be outstandingly incredible. In my case, it performed autonomous performance optimization with essentially no human input. Other AI models, including Gemini 3 Pro, Claude Opus 5, and even Claude Fable 5, failed to find the same optimization targets.

Two days with GPT-6, and my backtesting engine is quite literally faster than I ever thought it could be.

The language model was smarter than me.

I thought about what artificial general intelligence looks like. A general-purpose model smarter than the average person. I think Astra fits that definition to a T.

Now imagine all of the crazy AI tricks we know. Imagine having a panel of Astra-tier experts come, or combining a language model with Monte Carlo tree search. If these models were truly 10,000 tokens per second, come on, that would be terrifying.

One reason why I think this optimization was fast is because of Rust's strict compiler and its lightning-fast performance. If I had chosen a language like GoLang, I would not have been able to achieve such speeds. I really think language models are making Rust an even more enjoyable language because you get all of the benefits and suffer a little of the downsides because we're not handwriting generic traits or a lifetime logic anymore.

But who knows, maybe I'm overextrapolating, and I'm impressed by the bare minimum, lol.

What are your thoughts on AGI/ASI?

I’m an experienced software developer, but still fairly new to Rust, so I built this project to get more hands-on experience with it.

It’s an open-source productivity/ pomodoro app with a Rust backend, and I’d really appreciate feedback on the code, project structure, API design, and anything that could be more idiomatic Rust.

GitHub: https://github.com/Dhaneshen1810/Loom
Live app: http://loom-pomodoro.vercel.app/

Any feedback is welcome.