Skip to content
ESEN
Contact

Technology · Systems language

Software development in Rust

Rust is a language for writing fast, reliable software: it performs like C or C++, and its compiler rejects, before the program starts, whole families of errors that in other languages show up on the customer’s machine. We use it for the core of desktop applications, for services that cannot go down and to speed up the slow piece of a system you have.

Tell us about your project See an example

Often combined with

Fig. 01Line with a gauge and a single key1 EXECUTABLE1 EXECUTABLEPYTHON · NODEPORTGAUGE · SINGLE KEY · ONE BLOCKLooping
The gauge rejects the faulty piece before it enters the machine. Inside, a single key decides which arm may touch it: never two at once.

Situations

What you can solve with Rust

Rust pays off when a failure is expensive or when the program has to squeeze the machine: a lot of data, a lot of devices, or modest hardware that is not going to be replaced.

  • A program that crashes without warning

    Unexpected exits, memory that grows until the machine runs out, or corrupted data when two processes write at once. Rust prevents those failures at compile time; it does not detect them afterwards.

  • A slow piece in a system that works

    A calculation, an import or a report that takes too long in Python or Node.js. Only that part is rewritten in Rust, and the rest of the system uses it like any other library.

  • Software that talks to devices

    Scales, readers, industrial printers or machines with their own protocol, over serial port, USB or network. Rust works at that level without giving up safety.

  • A tool that installs and just runs

    A single executable, with no dependencies to install separately, that starts instantly and uses little. For workstations, servers or old machines.

The gauge: what does not fit never reaches the machine

What to check before starting

  • Which part of the system fails or runs slow, and how that is measured today
  • Which operating systems and machines it has to run on
  • Which other languages or programs it has to live alongside
  • Who is going to maintain the code afterwards

Services

What we build with Rust

Four kinds of job. The first one is often small: a single piece in Rust inside what already exists.

  • Module 1 · Solid block

    Native tools and services

    Command-line programs, background services and internal utilities delivered as a single executable for Windows, macOS and Linux.

    Examples of deliverables

    • Batch file converter
    • Synchronization service
    • Internal command-line tool
  • Module 2 · Single-key cell

    Core of desktop applications

    The logic, the data and the access to the system written in Rust, underneath the interface. The same base serves the desktop app and, if needed, the mobile one.

    Examples of deliverables

    • Calculation engine of an app
    • Files and local database
    • Logic shared by desktop and mobile
  • Module 3 · Cartridge

    Rust modules for Python and Node.js

    The slow part of an existing system, rewritten in Rust and published as a package your current code imports like any other.

    Examples of deliverables

    • Calculation module for Python
    • Native extension for Node.js
    • Processing of large files
  • Module 4 · Port

    Devices and protocols

    Communication with devices over serial port, USB, Bluetooth or network, with the retries and checks that are needed when the other side is a machine.

    Examples of deliverables

    • Reading a scale over a serial port
    • A machine’s own protocol
    • Gateway between devices and server

A working example

Three errors that never get to start

Simulated demonstration. Three typical bugs, told in words. Compile the program and see what the Rust compiler says about each one; apply the fix and compile again.

Simulated demo · sample data

The program, told in words

  1. Two threads add to the same counter at once.

    In other languages It compiles. Sometimes the total comes out wrong and nobody knows why.

  2. The list of orders is handed to another function and then used again.

    In other languages It compiles. The program crashes when it touches memory that is no longer its own.

  3. The discount of a customer who may have none is read.

    In other languages It compiles. It fails the day a customer with no discount arrives.

  1. Parse
  2. Check who uses each piece of data
  3. Build the executable

Compiler output (simulated)

  1. Press “Compile” to see what the compiler says.

There is no compiler behind this demonstration: the messages are prepared and summarized in plain language. What it shows is real: Rust rejects these three errors at compile time, before the program exists.

Integration

How it fits with your systems

Rust rarely arrives alone. It usually takes the center of an application, or one specific slot inside a system written in another language.

Where it comes from

RustCore or module in Rustfast and checked at compile time

Where it goes

Dependencies worth checking

  • Whether the team that will maintain it knows Rust or will need training
  • Which libraries in the ecosystem cover what you need and which do not
  • How it is compiled and signed for each operating system
  • What stays in the current language and where the boundary is

How we work and what we deliver

How we work on a Rust job

  1. 01

    Initial review

    We look at the system that exists, measure where it fails or where the time goes, and see what the new piece has to live with.

  2. 02

    Scope

    We write down what is done in Rust and what is not, how the improvement will be measured and which operating systems it ships for.

  3. 03

    First release

    The piece running on your machines with real data, next to the measurement from before and the one from after.

  4. 04

    Validation

    You test it with the hard cases: the huge file, the device that does not answer, the oldest machine.

  5. 05

    Documentation

    How it is compiled, tested and published, and which libraries it uses and why.

What you get when the job closes

  • The code in a repository in your name, with its tests
  • The executables for each operating system
  • The performance measurement from before and after
  • The list of what is left out, and why

Questions

Questions about Rust

Missing yours? Write it to info@veodar.com and we'll reply with a specific question, not a brochure.

Why Rust and not C++ or Go?

C++ gives the same performance, but lets through memory errors that Rust rejects at compile time. Go is simpler to learn and very good for services, although it has a garbage collector and gives less control over the machine. Rust pays off when speed, resource use and not failing all matter at once; if that is not your case, we say so.

Does my whole system have to be rewritten in Rust?

No, and it is almost never a good idea. The usual thing is to rewrite only the piece that fails or runs slow and connect it to what you already have: Rust integrates well with Python, Node.js, C and .NET. The rest stays as it is.

Is it hard to find someone to maintain Rust code?

There are fewer programmers than in JavaScript or Python, that is true, and the learning curve is longer. In exchange, the compiler forces tidy code that another person can pick up. We deliver the code with tests and documentation, and if your team is going to maintain it, we take that into account when deciding how much is done in Rust.

Is Rust any good for applications with an interface?

Yes. The most common approach is to put the logic in Rust and the interface in web technology, using Tauri; there are native interface libraries too. For a line-of-business application with many forms on Windows, .NET can be more direct, and we weigh that up with you.

How much faster is it?

It depends on where the time goes today, which is why we give no figure before measuring. If the bottleneck is calculation or data processing, the improvement tends to be large; if it is a database or a slow network, changing language does not fix it. The first thing we do is measure it.

Which systems does it run on?

The same code compiles for Windows, macOS and Linux, and also for mobile, for browsers, as WebAssembly, and for small devices. Each system has its own packaging and signing details, which are part of the job.

Updated:

Related services

All services

Other technologies

What it is combined with

All technologies
  • Desktop apps with TauriApplications for Windows, macOS and Linux with a web interface and a Rust core: light installers and scoped permissions. New, or migrated from Electron.
  • Concurrent services with TokioRust services that handle many connections and devices at once without blocking, with timeouts, retries and an orderly shutdown.
  • Rust in the browser with WebAssemblyThe same Rust code your desktop app uses, inside a web page: heavy calculations with no server, and isolated extensions.

Get started

Tell us which piece is failing or holding you back.

Knowing what the program does today, on which machines and where it hurts is enough for a first answer.

What helps us assess it

  • What the program does and where it fails or runs slow
  • Which language the existing part is written in
  • Which operating systems it has to run on
  • Whether devices or large files are involved
Tell us about your project info@veodar.com

Before you write, see how we price a project or our solutions by department.

Fig. 07Morse keyH · E · L · L · O