- Armadillo is a new, lightweight DNS server written in the Gleam programming language for homelab users.
- It aims to provide custom local DNS resolution, allowing users to assign memorable names to devices on their home network.
- Gleam is a functional language running on the Erlang VM (BEAM), known for its simplicity, speed, and fault tolerance, making it suitable for network services.
- Armadillo is currently in early development, offering basic DNS functionality but lacking the extensive features of mature tools like Pi-hole or Unbound.
- The project serves as a proof of concept for using Gleam in systems programming and offers a learning opportunity for developers interested in functional languages and infrastructure.
- Compared to established tools like Pi-hole, Unbound, CoreDNS, and Dnsmasq, Armadillo’s primary differentiator is its Gleam implementation, appealing to developers for experimentation rather than as a direct replacement for production use.
What Is Armadillo?
Armadillo is a DNS server built specifically for homelab use. It’s a small, open-source project on GitHub by a developer named vshakitskiy. The project was shared on Hacker News in May 2024, where it got modest attention. The idea behind it is interesting enough to deserve a closer look.
At its core, a DNS server translates domain names like “my-plex-server.local” into IP addresses like “192.168.1.100”. Without DNS, you have to remember and type IP numbers. With a local DNS server, you can give your devices memorable names. Armadillo aims to do this in a lightweight, easy to configure way, specifically for home networks where you might have dozens of devices.
The name Armadillo comes from the small, armored mammal that curls up into a ball. It’s a fitting metaphor for a compact, self contained server that protects your network from messy DNS configuration. Think of it as a custom navigation system for your home network, one that you can tweak and extend.
Right now, the project is in its early stages. The GitHub repository contains the source code, but detailed documentation is sparse. Based on the repository structure, it includes basic DNS server functionality, but it likely doesn’t have all the bells and whistles of mature tools like Pi-hole or Unbound. Armadillo is not trying to replace those tools yet. It’s more of a proof of concept, showing that you can build a DNS server in Gleam.
Why Gleam? The Language Behind the Armadillo Gleam DNS server
Gleam is a functional programming language that first appeared around 2019. It runs on the Erlang virtual machine (the BEAM), which is known for powering massively concurrent and fault tolerant systems like WhatsApp and RabbitMQ. Gleam’s syntax is clean and inspired by languages like Rust and Elm. It’s statically typed, meaning many errors are caught at compile time rather than when your program runs.
So why would someone write a DNS server in Gleam instead of the more common choices like Go or Rust? Let’s break that down.
Go is popular for networking tools. It’s simple, has a great standard library, and compiles to a single binary. Many DNS servers like CoreDNS are written in Go. Rust is also used for performance critical tools, like the DNS resolver Trust-DNS (now Hickory DNS). Go and Rust are both excellent for this kind of work, but they come with complexity. Go’s garbage collector can cause latency spikes. Rust has a steep learning curve with its ownership system.
Gleam sits in an interesting middle ground. It compiles to Erlang bytecode, which runs on the BEAM. The BEAM handles concurrency and fault tolerance automatically. If one part of your server crashes, it can be restarted without taking the whole system down. That’s a big deal for a DNS server, which needs to be always on. Gleam also avoids many of the pitfalls of Erlang, which has a syntax that some find strange. Gleam’s syntax is more like a modern language.
The author of Armadillo, vshakitskiy, has not publicly explained their motivation in detail. But based on the project and the language choice, it’s likely they wanted to explore how Gleam handles systems programming tasks. DNS is a good test case. It involves parsing binary protocols, handling concurrent requests, and managing state. Gleam’s type system and pattern matching make parsing complex data structures easier and less error prone.
Another reason might be the BEAM’s strengths. A DNS server needs to handle many queries at once, often from different clients. The BEAM’s lightweight processes could handle each query independently. If one process blocks, others keep running. That gives Armadillo potential for good performance even on modest hardware like a Raspberry Pi.
Of course, Gleam is still a niche language. Its ecosystem is small. There aren’t many libraries for DNS or networking. The author likely had to write a lot from scratch, which is why Armadillo is minimal right now. But that’s also part of the appeal for early adopters. Using Gleam means you’re part of a small, enthusiastic community that likes to build things from the ground up.
Homelab DNS: The Problem Armadillo Solves
If you have more than a few devices on your home network, you have probably run into the DNS problem. Your internet router usually provides DNS automatically, but it’s often slow, limited, and controlled by your internet provider. You can change your DNS to a public service like Cloudflare or Google, but that still doesn’t give you local name resolution.
Imagine you have a Raspberry Pi running a media server called “Plex”, a separate machine for backups, and a smart thermostat. With a local DNS server, you could name them “plex.home”, “backup.home”, and “thermostat.home”. Type those names in any browser, and you’re taken directly to the device, no IP addresses needed. That works even when your internet is down, because the DNS server is on your local network.
Homelab DNS also helps with ad blocking. Tools like Pi-hole work by acting as a DNS sinkhole. They intercept requests to known ad domains and return a non-answering IP or block the query entirely. Armadillo could potentially do that too, but the project doesn’t advertise that feature yet.
Another common use is controlling DNS for containers. If you run Docker on your homelab, DNS helps containers find each other by name. A lightweight DNS server that is easy to configure can replace Docker’s built in DNS in some setups.
The core problem that Armadillo addresses is technical curiosity and learning. Many homelab enthusiasts run their own DNS not because they have to, but because they enjoy controlling their network. It’s a sandbox for learning about networking protocols, programming, and system administration. Armadillo adds another layer: it’s a chance to learn a new programming language while solving a real problem.
What the Armadillo Project Offers (So Far)
As of the time of writing, Armadillo is very much a work in progress. The GitHub repository is public and contains the source code, but there is no packaged release or installation script yet. To try it, you need to have the Gleam compiler installed and compile the code yourself. That’s not uncommon for early stage projects, but it means Armadillo is aimed at developers who are comfortable with the command line and compiling from source.
The repository structure suggests that Armadillo implements basic DNS query handling. It likely listens on port 53 (the standard DNS port) and responds to queries for specific domains. It may or may not support recursive resolution, where the server goes out to the internet to find the answer if it doesn’t know it. Many homelab DNS tools offer both authoritative (for local domains) and recursive resolution. Without detailed documentation, it’s hard to say which Armadillo does.
The project also likely includes a configuration file format, probably in something simple like TOML or JSON, where you define your local domains and their IP addresses. For example, you could map “my-server.home” to “192.168.1.50”.
One notable feature that may appear in the code is support for DNSSEC (DNS Security Extensions), but that’s speculative. For a minimal server, even basic caching is a plus. Caching means that if you query the same domain twice, the server remembers the answer and responds faster the second time.
The fact that the project has zero comments on Hacker News and only 10 points suggests it hasn’t been widely tested yet. That’s normal for such a new project. It means there aren’t many user reports or feature requests. The author is likely still figuring out what the project should become.
What Armadillo offers most is a starting point. For developers who are curious about Gleam and want to contribute to a real world project, Armadillo is a small codebase that is easy to understand. It’s not overwhelming. You can read the whole thing in an evening and start modifying it.
How Armadillo Compares to Other Homelab DNS Tools
The homelab community has plenty of DNS options. Let’s compare Armadillo to a few popular ones: Pi-hole, Unbound, CoreDNS, and Dnsmasq.
Pi-hole is the most famous. It’s built on top of FTLDNS (a fork of Dnsmasq) and adds a web interface for statistics and ad blocking. Pi-hole is written in C and runs well on low power devices. It’s easy to install, even for beginners. Armadillo cannot compete with Pi-hole’s features or community support. Pi-hole has years of development, thousands of plugins, and a huge user base. Armadillo is a single person’s side project.
Unbound is a recursive and validating DNS resolver from NLnet Labs. It’s written in C and is known for security and correctness. Unbound does not block ads by itself. It’s focused on being a proper DNS server that follows all the standards. Armadillo is nowhere near Unbound’s level of reliability or feature completeness. Unbound has been around for two decades.
CoreDNS is written in Go and is often used in Kubernetes environments. It’s extensible via plugins. You can use it in your homelab too, but it’s designed for cloud native setups. CoreDNS is modern and fast, but configuring it requires understanding Go modules and plugin chains. Armadillo is simpler, which might appeal to people who find CoreDNS too complex.
Dnsmasq is a lightweight DNS forwarder and DHCP server. It’s included in many Linux distributions and routers. Dnsmasq is minimal, written in C, and very reliable. It doesn’t have a fancy interface, but it just works. Armadillo is even more minimal than Dnsmasq, at least for now.
The main advantage Armadillo has over these tools is that it’s written in Gleam. That’s not useful to most people. But for developers who want to hack on a DNS server using a modern functional language, it’s a unique opportunity. You can’t easily extend Pi-hole with your own code. You can fork Armadillo and change anything. It’s a learning tool, not a production replacement.
Tuning aside, if you just want a working DNS server today, stick with Pi-hole or Unbound. If you want to experiment with Gleam and build something from scratch, Armadillo is a great starting point.
What This Means for Gleam’s Future in Infrastructure
Armadillo is a tiny example of a larger trend. Functional programming languages are slowly moving into infrastructure and systems programming. Languages like Rust have become popular for tools like build systems, compilers, and networking software. Haskell has been used for things like the software defined networking tool Frenetic. Erlang and Elixir already power big parts of the internet.
Gleam is a newcomer that aims to make functional programming more accessible. It’s statically typed like Rust but simpler. It runs on the BEAM, which handles concurrency and fault tolerance automatically. Those are exactly the properties you want in a DNS server, a web server, or a message queue.
If projects like Armadillo gain traction, they could encourage more developers to try Gleam for infrastructure tasks. That doesn’t mean it will replace Go or Rust. The ecosystems are too small. But it could carve out a niche. For example, Gleam could become a good choice for building small, reliable network services that need to handle many concurrent clients without crashing. DNS is a perfect example.
The homelab community is a great testing ground for new languages. People who run homelabs are often early adopters. They are comfortable with experimental software. If Armadillo works well for them, they might recommend Gleam to their colleagues or use it in their day jobs. That’s how many languages, including Python and Node.js, grew from hobby projects to mainstream tools.
There is also a chance that Armadillo’s author, vshakitskiy, is laying groundwork for a more ambitious tool. Maybe they plan to add support for DNS over HTTPS, or a web interface, or integration with container orchestration. Even if Armadillo stays small, it’s a data point in the argument that functional languages can handle real world networking problems.
The lack of comments on Hacker News might be a sign that the project isn’t ready for prime time. But it also means the community hasn’t fully seen what Gleam can do in this space. If the author continues development and shares more, the Armadillo Gleam DNS server could become a notable project.
Frequently Asked Questions
What is Armadillo?
Armadillo is a lightweight, open-source DNS server written in the Gleam programming language. It's designed for homelab users who want to manage their local network's DNS resolution, allowing them to assign custom, easy-to-remember names to their devices instead of using IP addresses.
What is Gleam and why is it used for Armadillo?
Gleam is a modern, functional programming language that runs on the Erlang virtual machine (BEAM). It's chosen for Armadillo because the BEAM is known for its high concurrency and fault tolerance, which are crucial for a reliable DNS server. Gleam offers a simpler syntax than Erlang while leveraging the BEAM's strengths.
How does Armadillo help in a homelab?
In a homelab, Armadillo can provide custom DNS names for local devices, making them easier to access. This is useful for services like media servers, NAS devices, or smart home hubs. It offers a way to control your network's name resolution locally, independent of your ISP or public DNS providers.
Is Armadillo a replacement for Pi-hole or Unbound?
No, Armadillo is not currently a replacement for established tools like Pi-hole or Unbound. It is in the early stages of development and offers basic functionality. Pi-hole and Unbound are mature projects with extensive features, community support, and robust performance.
Who is Armadillo for?
Armadillo is primarily for developers and homelab enthusiasts who are curious about the Gleam programming language and want to experiment with building network infrastructure tools. It's a learning project and a starting point for contributing to a new codebase.
How do I install or use Armadillo?
As Armadillo is in its early stages, there are no pre-packaged releases or simple installation scripts. Users typically need to have the Gleam compiler installed and compile the source code themselves from the GitHub repository. This makes it suitable for users comfortable with command-line tools and compiling software from source.
What are the advantages of using Gleam for a DNS server?
Gleam, running on the BEAM, offers excellent concurrency and fault tolerance, meaning it can handle many DNS requests simultaneously without crashing. Its static typing helps catch errors early, and its functional nature can lead to more predictable and maintainable code for network services.
