ymawky: A Minimalist Web Server Hand-Crafted in ARM64 Assembly

ymawky presents an intriguing approach to web server development—a complete implementation written entirely in ARM64 assembly with no external library dependencies. This minimalist project demonstrates the fundamentals of web server functionality at the most basic level possible.

What is ymawky?

yawmky is a syscall-only, no-libc, fork-per-connection web server hand-written in ARM64 assembly. Developed specifically for macOS on Apple Silicon, it implements HTTP server functionality directly through system calls, bypassing standard libraries entirely.

The project's approach is noteworthy for its extreme minimalism. Rather than building upon existing frameworks or libraries, the creator implemented everything from scratch, including HTTP parsing, file serving, and request handling—all in assembly language.

Technical Implementation

Architecture

ymawky follows a fork-per-connection model, where each incoming request spawns a new child process to handle it. This design contrasts with modern event-driven architectures but represents a straightforward approach to concurrent request handling.

The implementation relies exclusively on macOS system calls, using the svc #0x80 instruction for syscall invocation. The code directly interacts with the kernel for all operations, from socket creation to file I/O.

Key Features

Despite its minimal implementation, ymawky supports several essential web server features:

• Static file serving with automatic index.html handling
• HTTP methods: GET, PUT, DELETE, OPTIONS, HEAD
• Path traversal protection against directory traversal attacks
• MIME type detection based on file extensions
• Range request support for video streaming and large file downloads
• Atomic PUT operations using temporary files
• Custom error pages with support for numerous HTTP status codes
• Basic DoS protection through timeout mechanisms

Configuration

The server is configured through a config.S file, allowing customization of:

• Document root directory
• Default file
• Error page directory
• Timeout values
• Maximum upload size
• Maximum concurrent processes

This approach demonstrates how even complex configuration can be implemented without external libraries.

Limitations and Constraints

While technically impressive, ymawky has significant limitations:

1. Platform dependency: While designed for macOS, the code contains numerous macOS-specific implementations that would require substantial modification for Linux or other Unix systems.

2. Architecture restriction: Only runs on Apple Silicon (arm64), not on Intel-based Macs.

3. Network restrictions: Binds only to 127.0.0.1, preventing external access.

4. Limited HTTP support: No server-side code generation, advanced URL parsing, or modern HTTP features like keep-alive.

5. Security considerations: The author explicitly notes it "probably has a lot of vulnerabilities" and should not be used in production.

Analysis of the Approach

The ymawky project represents an interesting educational exercise in systems programming. By implementing a web server entirely in assembly, the creator demonstrates:

• Direct system call usage
• Low-level network programming
• HTTP protocol implementation
• File system interaction
• Process management

However, the approach also highlights why modern web servers are typically implemented in higher-level languages. Assembly code is difficult to maintain, debug, and extend. The absence of standard libraries means reimplementing common functionality that would otherwise be readily available.

The project's safety features are notable but rudimentary compared to mature web servers. Protection against basic attacks like path traversal and slowloris is implemented, but the code lacks the comprehensive security testing and review that production systems require.

Practical Applications

While not suitable for production use, ymawky serves several valuable purposes:

1. Educational resource: Provides a complete, minimal implementation of HTTP server fundamentals
2. Systems programming reference: Shows direct interaction with kernel APIs
3. Performance experiment: Offers a baseline for comparing against higher-level implementations
4. Security research: Presents a simple codebase for analyzing web server vulnerabilities

Conclusion

ymawky stands as an impressive technical achievement, demonstrating that even complex systems like web servers can be implemented with minimal dependencies. The project showcases deep understanding of both the HTTP protocol and low-level system programming.

For those interested in exploring the code, the GitHub repository contains the complete implementation, along with build instructions and configuration details. The project serves as both an educational resource and a testament to the power of minimalist programming approaches.

While unlikely to replace mainstream web servers, ymawky offers valuable insights into the fundamental building blocks of web infrastructure. It represents a different approach to software development—one that prioritizes understanding and minimalism over convenience and abstraction.