Let me spoiler, it's the best I've seen so far for bhyve and FreeBSD! When Stefano told me about Sylve, I just had a quick look at the GitHub project and thought, "okay, just another of thousands jail manager just with a better web ui, similar to the Proxmox one" and I got completely wrong while giving it a try!
When looking at virtualization and container management on FreeBSD, you quickly notice that while there are many tools around, most of them either feel outdated or are missing important features. Some work well in the background but fail when it comes to usability and modern interfaces. This is exactly where Sylve caught my interest.
Sylve is an open-source project that tries to make virtualization on FreeBSD simple and user friendly. It uses Bhyve for virtual machines, Jails for containers and takes advantage of ZFS for storage. The backend is written in Go and the frontend in SvelteKit, which gives it a clean and modern look. The idea behind it is to provide something similar to Proxmox but made for FreeBSD.
I first heard about Sylve from Stefano, and after taking a quick look at the project, it already felt more modern than other solutions in this space. This alone could make a big difference, since many people refuse to work with tools that look and feel outdated. If we want to push FreeBSD further into companies, this kind of modern design becomes very important.
When I tried it myself, the installation went without any issues. Everything worked right away, and I will go through the process step by step later in this post. While testing it, I discovered something that really stood out: the option to create a cluster. Managing multiple nodes with a single interface has always been missing in the FreeBSD world of jail and bhyve managers. Even ClonOS, although built on top of the powerful CBSD framework, never offered this in its interface. At first, I thought the cluster feature might just be a placeholder that would never really work. I was wrong. I managed to set up a three node cluster on FreeBSD 14.3 within minutes. It was simple, clear and fully functional. That was the moment when the project really convinced me.
If we want FreeBSD to be taken more seriously in enterprises and if we want adoption to grow, we need better interfaces that people enjoy using. Sylve delivers exactly that. It feels modern, it works well and it shows that FreeBSD can compete in areas where design and usability matter. The project is still in active development, but my first experience with it was already very promising.
Installing Sylve
At the moment there are no ready-to-use packages for Sylve. The only way to get it running is by compiling it from source. This might sound complicated at first, but it is actually straightforward once the required tools are in place. To build Sylve you need a working setup with Go, Node and NPM, since both the backend and frontend are built from source. In the future Sylve will be available as a single self-contained binary, which will make the installation process even easier. Until then, compiling is the only option we have. The good news is that it works reliably and only takes a few steps to complete.
Development Requirements
o Go >= 1.24
o Node.js (v20.18.2)
o NPM (v10.9.2)
Runtime Requirements
o smartmontools
o tmux
o bhyve-firmware
o samba419
o libvirt
o jansson
Before we start installing Sylve, we need to install all further required packages to build and run Sylve, which can simply be installed by pkg by running:
pkg install smartmontools tmux bhyve-firmware samba419 libvirt git jansson go node npm
After installing the packages, we need to enable the following services in /etc/rc.conf to start automatically on system boot:
ntpd_enable="YES"
ntpd_sync_on_start="YES"
zfs_enable="YES"
linux_enable="YES"
libvirtd_enable="YES"
dnsmasq_enable="YES"
rpcbind_enable="YES"
nfs_server_enable="YES"
mountd_enable="YES"
samba_server_enable="YES"
Before building Sylve, we also need to enable the RACCT/RCTL framework which takes control over the resource accounting and limits in FreeBSD:
echo 'kern.racct.enable=1' >> /boot/loader.conf
You should now reboot the node to take the changes affect and we can move over building Sylve from source. Therefore, we simply clone the remote git repository and simply execute the Makefile:
git clone https://github.com/AlchemillaHQ/Sylve.git
cd Sylve
make
Sylve also checks for all required dependencies and proceeds building:
root@gyptazy-fbsd-dev01:~/Sylve # make
=== Checking system dependencies for building Sylve ===
✅ OS Check: Running on FreeBSD.
✅ node found: v22.17.1
✅ npm found: 10.9.3
✅ go found: go version go1.24.4 freebsd/amd64
✅ tmux found: tmux 3.5a
✅ virsh found: 11.5.0
=== Dependency check completed ===
After building Sylbe from source, we need to copy over the example config. Within the config, you need to adjust your uplink / wan interface to make sure further networking related things will work properly:
cp config.example.json bin/config.json
cd bin/
./sylve
After starting the Sylve process, we can already login on the web-ui on tcp/8181 via https. If you didn't change the credentials in the config file, the following defaults credentials apply:
https://node01.lab.gyptazy.com:8181
User: admin
Pass: admin
At this point, Sylve is already compiled, running and fully usable as a single node instance.
Webinterface
Sylve comes with a webfrontend by default, running on every node and reachable out of the box on TCP port 8181 via HTTPS. The interface is written in SvelteKit, which makes it fast, lightweight and responsive. From the first moment it feels very modern, probably the most polished and up-to-date interface I have seen so far for BSD related systems. Its design and usability are strongly inspired by Proxmox VE, following many of the same concepts and layouts. This makes it easy for users familiar with Proxmox on Linux to switch over and feel comfortable when working with Sylve on FreeBSD. By providing such a modern and familiar interface, Sylve finally closes a gap that has been holding back FreeBSD adoption for years, and it could be exactly the approach needed to push the system into more homelabs and enterprise environments.
During the current development state you may still encounter some UI issues which is absolutely fine for WIP and not yet released project. On the other site, you can also already see many smaller details, like rotating and dynamic progress icons etc., including several other smaller but pretty nice ui things. I'm heavily looking forward to the first official release!
Clustering
One of the first things that really impressed me when trying out Sylve was the built-in clustering feature. I honestly didn’t expect this to be already functional, but it is. I was able to set up a three node cluster without running into any problems at all. Everything worked straight away, and this alone makes Sylve stand out from other solutions I have tested before.
The user interface for clustering might still feel a little bit confusing at the moment, but this will be adjusted soon. Even now it is easy enough to understand once you get the idea, and the way it works will feel familiar to anyone who has used Proxmox before. You start by creating a cluster on one node, and from there the other nodes can simply join the cluster. What is happening under the hood is very different from Proxmox though. Sylve is not based on corosync. Instead it uses the HashiCorp RAFT library for communication between nodes. The cluster state is replicated over RAFT and stored inside lightweight SQLite databases on each node. This approach makes it simple but also robust.
At the moment there is no live migration available for bhyve virtual machines or Jails. This means that workloads cannot be moved between nodes while running. However, cold migrations are already on the roadmap and will be added in the future. Features like high availability are not part of the project right now and remain out of scope for the current development phase. However, you can already interact with nodes from other nodes in a multi-master alike approach. This way, you can manage resources on any node like creating guest objects. You can create a bhyve based VM or Jail from any node on any node, and you can simply edit resources and orchestrate the power control the same way.
As you can see in this image, the node test03 also holds guests which can be collapsed, but doesn't work with multiple collapsed items at the same time - some really minor ui bugs. And even with these limitations, clustering in Sylve is already one of its strongest points. The fact that it is fully functional today, with such a simple setup process, makes it a real game changer for FreeBSD users who always missed proper cluster management in the past.
Storage
The current focus of Sylve is clearly set on ZFS, and the web interface already provides a great graphical overview of storage usage. Just like in Proxmox, you can see and work with the physical disks directly, which makes handling storage much more transparent. Pools and datasets can be created and managed from the webui, and snapshots are also supported out of the box. On top of that, Sylve already integrates with Samba/CIFS, making it possible to share datasets over the network with only a few clicks. In theory, NFS should also work at least on the CLI side with options for mounting or linking paths, although I haven’t tested this part yet. Looking ahead, iSCSI integration is planned as part of the roadmap, which could add another important enterprise feature and raise awareness of Sylve as a serious storage and virtualization platform for FreeBSD.
ISO Usage / Base for Jail
Adding new ISO files or BSD base images for Jails might be a bit confusing and took me a bit to understand this approach. Unlike adding storage for those kind of content like in Proxmox or simply attaching the ISO to a CD-Rom wasn't possible. Such kind of content is defined in the scope of a node and can simply be added within:
The node scope -> Utilities -> Downloader -> New
Afterwards, you can simply add a remote URL to fetch the content. I'm giving this an extra section, because this might be the most confusing part.
Roadmap
Before Sylve reaches its first stable release, several key features are planned to be implemented. These are structured into versions, each focusing on specific functionality that will make the platform more complete and practical for production use.
o iSCSI implementation
o Firewall integration
o Additional switch types (including support for bonds and similar setups)
o DHCP server implementation based on dnsmasq
o WireGuard integration
o Zelta integration for backups
o Ability to join multiple Sylve instances together
Once these features are in place, the focus will shift to polishing and refining the platform to prepare for the v1.0.0 release.
Conclusion
After exploring Sylve in depth, I have to say I am genuinely impressed. Even in its current work-in-progress state, it already delivers a modern, functional, and user-friendly experience that FreeBSD virtualization has been missing for a long time. The web interface feels polished and intuitive, clustering works out of the box, storage management with ZFS is clear and practical, and features like Samba/CIFS integration make it immediately usable.
What excites me the most is that Sylve isn’t just a single-node manager. The fully functional clustering, combined with the modern UI and the planned roadmap, shows that this project is designed with real-world usage and adoption in mind. Even now, you can manage multiple nodes, create VMs or Jails across the cluster, and interact with resources in a way that feels natural and powerful. With features like iSCSI, Firewalls, WireGuard, DHCP, and backup integration on the roadmap, Sylve is on track to become a complete FreeBSD virtualization platform. I’m especially excited about the potential this has to increase FreeBSD adoption in both homelabs and enterprise environments, offering a level of usability that hasn’t existed in the ecosystem until now.
Even though it is still under active development, my first experience has been smooth, intuitive, and extremely promising. Sylve has already shown that FreeBSD can compete with Linux-based solutions in terms of usability and functionality, and I can’t wait to see how it evolves towards the first official release. And if you're more interested into it or still have open questions, I suggest you to join Dexters' bhyve weekly call!