Every license server vendor ships its own management interface — or none at all. If you run Autodesk on FlexLM, SideFX on sesinetd, and Foundry on RLM, you’re checking three different tools, running three different commands, and piecing together a picture of your license infrastructure from fragments.
Commercial alternatives exist, but they cost thousands per year. Open-source options are typically single-vendor (FlexLM only) and haven’t been updated in years. Meanwhile, your team is still running lmstat -a in a terminal and hoping nobody quietly exhausted the last Houdini license during a deadline crunch.
License Management Platform is two open-source tools that work together:
License Monitor
A Rust agent that runs on each license server. It executes vendor commands on a schedule, parses the output with per-vendor Python parsers, and exposes everything through a REST API with WebSocket and Server-Sent Events streaming. Built on Tokio and Axum for reliability under load.
License Server Detail
A Next.js dashboard that connects to every License Monitor instance you deploy. Real-time license usage, server health, renewal tracking, and operational views — behind Okta SSO, backed by Convex for inventory and history.
One agent per server. One dashboard for everything. Data stays on your infrastructure.
Each parser transforms vendor-specific output into a standardized format: server status, available features, usage counts, user checkouts, and expiry dates. Every parser is a standalone Python script — adding a new vendor requires no changes to the core agent.
Autodesk (Maya, 3ds Max, Revit), Avid (Media Composer, Pro Tools), KeyShot, Rhino 3D, ToonBoom (Harmony, Storyboard Pro)
FlexLM is the most common license manager in the industry. The parsers handle lmstat output across vendor-specific formatting differences.
Foundry (Nuke, Katana, Mari), Maxon (Cinema 4D, Redshift), NeatVideo, SpeedTree
Reprise License Manager parsers handle rlmstat output and vendor-specific extensions.
SideFX (Houdini, Karma, PDG)
The most comprehensive parser in the set — built for the complexity of SideFX’s licensing model with workstation, engine, and indie tiers.
RizomUV (LM-X), JangaFX (EmberGen, VectorayGen), plus a framework for custom parsers
If your software has a local executable that emits license or status information, you can write a parser for it. The Python parser framework makes this straightforward.
Deploy License Monitor on each machine running a license server. Configure it with the vendor, command path, and polling interval.
License Monitor collects data by executing vendor commands on schedule (or tailing log files in real time), parsing the output through the appropriate vendor parser.
Data is available instantly via REST API, WebSocket streams, or Server-Sent Events. License Monitor also forwards metrics and logs to any OpenTelemetry-compatible endpoint.
License Server Detail connects to every Monitor instance, presenting a unified dashboard with real-time usage, health status, and historical data.
Real-time streaming
WebSocket and SSE streaming with intelligent connection pooling and automatic fallback. See license checkouts and releases as they happen — no polling delay.
Self-hosted, your data
Deploy on your infrastructure, behind your firewall. No SaaS dependency, no license data leaving your network. MIT licensed.
OpenTelemetry native
Metrics and logs ship to any OTLP-compatible backend. Integrate with your existing Grafana, Datadog, or Axiom setup without extra configuration.
Self-updating
License Monitor checks for updates automatically via GitHub Releases, with SHA-256 verification and one-command rollback. Stable and beta channels supported.
This project started the way most infrastructure tools do: out of frustration.
I was managing license servers at a studio where artists ran Houdini, Maya, Nuke, and Cinema 4D — each on a different license manager, each with its own command-line tool and its own way of reporting status. Checking whether licenses were available meant SSH-ing into multiple machines, running vendor-specific commands, and mentally assembling a picture of what was happening across the fleet.
When licenses ran out during a production deadline, nobody knew until an artist hit an error dialog. By then, the damage was done — blocked renders, stalled pipelines, frustrated people.
The commercial tools that solve this problem are expensive. OpenLM, License Statistics, JTB FlexReport — they work, but they start at thousands per year, and for smaller studios, schools, and IT teams, the budget simply isn’t there. The open-source alternatives were either abandoned, limited to a single vendor, or required stitching together Prometheus exporters and Grafana dashboards that still only covered FlexLM.
So I built what I needed: a lightweight Rust agent that could talk to any license manager, parse any vendor’s output, and expose it all through a modern API. Then a dashboard that could connect to every instance and show the whole picture in one place. Real-time. Vendor-agnostic. Self-hosted.
The 13 vendor parsers reflect real production use — these are the tools that studios, schools, and engineering teams actually run. The architecture reflects real operational constraints — it needs to run reliably on the same servers as the license managers, use minimal resources, and stay out of the way.
This is now open source because the problem is universal. Every organization running licensed software deserves visibility into what they’re paying for and how it’s being used, regardless of budget.
IT operations teams
System administrators managing licensed software across any industry. If you’re running FlexLM, RLM, or sesinetd servers and want unified monitoring without the enterprise price tag.
VFX and animation studios
Pipeline TDs and IT staff running Houdini, Maya, Nuke, Cinema 4D, and other creative tools. The deepest parser coverage is for the software your artists use every day.
Schools and universities
IT teams managing software lab licenses on tight budgets. Track seasonal usage patterns, justify license spend to administration, and ensure students always have access when they need it.
Render farm operators
Teams running large compute clusters where license availability directly impacts throughput. Real-time visibility prevents queued jobs from failing on license exhaustion.
