Introducing YggdraSIM
Mikk Lemberg
We're open-sourcing YggdraSIM today. It's the SIM and eSIM testing toolkit we've been quietly running on inside 1oT for the past several months.
In one sentence: YggdraSIM is a Python suite that pulls card administration, OTA local administration, eSIM relay flows, profile-package tooling, and hardware-in-the-loop capture into one workspace, so the SGP.02 / SGP.22 / SGP.32 work all lives in one place.
- Repo: https://github.com/1oT/YggdraSIM
- Docs: yggdrasim.1ot.com
Why we built it
Running a global eSIM operation has gotten harder as we've grown. More eUICC vendors to validate against every year, more MNOs, more profiles to track. When you're shipping connectivity that has to work on a customer's device on whatever network it happens to roam onto, the testing surface expands faster than the tools you have to test it with.
We expanded our data generation work and started authoring profiles ourselves instead of relying on others. The work got more demanding and the tooling we had didn't really keep up.
The truth is, there isn't a good open toolkit for this work today. pySim from the Osmocom community is excellent, and we lean on it heavily. Martin Paljak's GlobalPlatformPro, same. Past those two, you're mostly stuck with vendor-specific test rigs that don't talk to each other. Most of them are Windows-only and GUI-only, which means engineers end up physically carrying cards between workbenches to get through a single test sequence. That's also assuming you can afford the rigs in the first place. Plenty of teams can't.
So for the day-to-day of running several eUICCs with multiple bootstrap profiles and operator profiles in flight, there just wasn't one workspace that did it.
How it came together
YggdraSIM is largely the work of one person: Hampus Hellsberg joined us in autumn 2025 as IoT Connectivity Engineer, bringing six years of hands-on experience across the full SIM/eSIM stack, and has led the project from the start.
The origin is one of those small decisions that turns into a project. Hampus moved his daily environment from Windows to Linux because that's where the Osmocom SIMtrace2 toolchain runs properly. The catch: most of the existing SIM tooling is Windows-locked. And, worse, GUI-locked. Which means you can't drive it from CI, you can't run it over SSH on a Pi sitting next to a card reader, and you can't parallelise it past whatever workbench you happen to be standing at.
We could have papered over that with Docker or a VM. Those workflows are slow and clumsy though, so instead of working around the gap we started filling it. A few scripts first. Then a more coherent set of shells. Eventually what became YggdraSIM: a launcher and a set of operator surfaces, each one a focused shell for a specific layer of the SIM stack.
YggdraSIM testing toolkit capabilities
You move between card administration, profile download, OTA work, and on-card capture without leaving the project. State, runtime root, and inventory are shared across all of them.
The surfaces I'd point at first:
- The eSIM relay and eIM-local shells. This is the SGP.22 / SGP.32 download path. Live relay, test relay, direct local ISD-R, and eIM-local package all sit next to each other. The local ISD-R path is worth flagging on its own. It lets you load and tear down profiles without an SM-DP+ in the loop, so you can exercise card behaviour offline before any server-side work is in place.
- The SAIP profile-package tool. Inspect, lint, transcode, encode, split, extract. Linting runs against the SAIP interoperability spec, so you find out a profile is malformed before a card does. There's an interactive builder for assembling profiles from scratch, plus a hex decoder for picking apart what's actually on the wire.
- The HIL Bridge. A SIMtrace2-backed bridge that lets a real card live in a reader while it serves a modem, with full APDU capture and a Wireshark mirror over GSMTAP. The first time you replay a production failure offline from a pcap, you'll understand why we bothered.
- All of this is shell-driven and pipeable. Commands chain across surfaces. You can capture an APDU stream from the HIL Bridge, pipe it into the SAIP tool to decode a specific package, pipe that into the relay shell to replay it on a different card. The same shells you drive interactively also run fine as CI steps.
There's also a local admin shell, an SCP80 OTA shell, a SUCI key tool, and a card simulator backend, but the four above are where we'd start anyone new.
Why open source
Mostly because we couldn't have built this without the open-source secure-element community in the first place. pySim is the foundation for the SAIP and authentication paths in YggdraSIM. The wider Osmocom work on RSPRO, SIMtrace2, and the rest of that ecosystem is what made the HIL workflows possible at all.
GlobalPlatformPro shaped how we think about the GP layer. We owe a lot of people. Contributing back felt right.
There's a second thing too. The SIM ecosystem is healthier when more of it is open. The standards are public. The protocols are public. The tooling mostly isn't. It's locked inside vendors and operators, or behind NDAs. That's a tax on anyone trying to do this work seriously, and we'd rather not be the people charging it.
Where we're using it
Inside 1oT, YggdraSIM has become the daily driver for our eUICC interoperability work. It started in the eSIM team and has spread. Support reaches for it during customer triage. The product team uses it during profile reviews. We lean on it whenever we're onboarding a new EUM or bringing a new operator profile into our data-generation pipeline.
If you work on the SIM stack at all, give it a try and tell us what's broken.
.avif)
.avif)
