Summary
At first, I didn’t notice anything had changed.
My Matter devices continued working normally, the Home Assistant dashboard displayed the correct device states, and there were no warning signs in the logs. Behind the scenes, however, Home Assistant had quietly replaced one of its most important components.
The Matter Server, which acts as the bridge between Home Assistant and every Matter device on your network, has been completely rewritten. Instead of relying on Python bindings connected to the official C++ CHIP SDK, it now runs on matter.js, a full TypeScript implementation of the Matter protocol.
The previous python-matter-server has officially reached the end of its lifecycle, with version 8.1.2 serving as its final release. Its successor, matterjs-server, has been available to beta users since January and is now becoming the standard implementation.
If you use Matter with Home Assistant—or you’re comparing Matter with alternatives like Zigbee—this transition represents a much bigger change than it initially appears. It also offers valuable insight into the future direction of the Matter ecosystem.
The Original Matter Server Was Built on a Difficult Foundation
Maintaining the C++ CHIP SDK Became Increasingly Complex
Although the original Matter Server was presented as a Python project, it wasn’t truly built in Python.
Instead, it functioned as a Python wrapper around the official Matter (formerly CHIP) SDK, a large C++ codebase maintained by the Connectivity Standards Alliance.
To make this possible, developers maintained a separate chip-wheels project responsible for compiling the C++ SDK into Python packages for every supported platform.
That project has now been archived as well.
Managing native dependencies is challenging for any software project, but it becomes even more complicated when supporting hardware ranging from Raspberry Pi systems to x86 servers.
Every SDK update required rebuilding packages, every platform introduced unique compatibility challenges, and the Home Assistant developers had limited control over the protocol implementation because it lived inside an external C++ codebase.
Why matter.js Is a Better Long-Term Solution
A Complete TypeScript Implementation Without Native Dependencies
The new matter.js server takes a fundamentally different approach.
Rather than depending on the official CHIP implementation, the entire Matter protocol has been recreated in TypeScript, eliminating the need for native C++ dependencies altogether.
Using automated code generation, matter.js builds a fully typed representation of every Matter cluster directly from the official specification.
As a result, when new device types or protocol clusters are introduced, they can be generated automatically instead of requiring lengthy manual C++ ports.
This also creates an independent implementation of the Matter standard.
According to the matter.js development team, having multiple implementations helps validate the specification itself by ensuring that different codebases interpret the standard consistently.
While rewriting a protocol stack in TypeScript might normally sound unconventional, in this case it provides clear advantages for maintainability, portability, and future development.
What Changes With the New Matter Server?
A Seamless Upgrade With Meaningful Improvements
One of the primary goals of matterjs-server was making the transition virtually invisible.
The new server exposes the same WebSocket API already used by the Home Assistant Matter integration, supports Matter 1.4.2, and automatically migrates existing installations.
During its first startup, it imports the previous server’s chip.json configuration along with existing fabric data, converts everything into its new storage format, re-interviews connected Matter devices, and continues operating without requiring manual intervention.
On my own system, the migration completed within a few minutes and felt no different from a routine Home Assistant update.
Although compatibility remains the priority, several meaningful improvements have been introduced behind the scenes.
Better Thread Network Performance
Smarter Device Connection Management
One of the most practical enhancements involves how the server communicates with Matter devices.
The new implementation automatically determines whether each device is connected via Thread or Wi-Fi/Ethernet.
Instead of opening simultaneous connections to every Thread device—which can overwhelm larger Thread networks—the server intelligently queues those connections.
As your Thread deployment grows beyond just a few sensors, this approach helps improve network stability and overall responsiveness.
Additional Features Improve Everyday Management
More Tools for Power Users
The rewrite also introduces several quality-of-life improvements.
A community-maintained Custom Clusters package allows support for manufacturer-specific features that aren’t included in the official Matter specification.
Debugging has become more convenient as well.
Instead of restarting the Matter Server to change logging verbosity, you can now adjust the log level directly from the dashboard, making troubleshooting much faster when diagnosing unreliable devices.
One of the standout additions is a built-in visualization tool.
The Matter Server web interface can now display graphical representations of your Thread or Wi-Fi network topology, providing a much clearer overview of how devices are connected.
A Few Things to Keep in Mind
New Requirements and Small Configuration Changes
While the migration is largely seamless, there are a few differences worth noting.
The new server requires Node.js 22.13 or newer.
In addition, fresh installations generate a random Fabric ID by default instead of using the fixed value of 1 employed by the previous Python server.
Existing installations that migrate from the older implementation retain their original Fabric ID, so no additional configuration is necessary.
The Gradual Rollout Was Intentional
Certification Delayed the Stable Release
The transition to matter.js wasn’t rushed.
Certification requirements resulted in a deliberately slow rollout, allowing developers to verify compatibility before making it the default implementation.
Now that the Matter Server has reached version 9.1.0, all new installations automatically receive the TypeScript-based server instead of the retired Python version.
It’s also worth recognizing that this project is developed by the Open Home Foundation and funded through Nabu Casa.
At a time when many smart home platforms continue prioritizing cloud services over local control, it’s encouraging to see an open-source project leading innovation in core smart home infrastructure.
Final Thoughts
The best software upgrades are often the ones users never notice.
That’s exactly the goal of matterjs-server.
If your lights, sensors, and automations continue working exactly as they did before, then the migration has succeeded.
Behind that seemingly uneventful transition, however, lies a far more modern architecture.
A fully typed, code-generated, dependency-free Matter implementation is significantly easier to maintain and better prepared to evolve alongside future versions of the Matter specification.
As Matter 1.6 and later releases introduce new capabilities, those features can be implemented through generated cluster code instead of requiring months of manual C++ development.
For anyone who has been waiting for Matter to mature before adopting it, this rewrite is a strong indication that the platform’s underlying foundation is becoming more stable and sustainable.
My own Thread network made the transition without losing a single connected sensor—and that’s a strong sign the new Matter Server is already delivering on its promise.