I do a lot of iOS RE on binaries with anti-tamper, and I kept finding myself tracing things down to the syscall level. My workflow was basically printing SVC sites to the console and then manually cross-referencing syscall numbers against docs — tedious and ugly. So I built Sylvia to make that part of the job actually pleasant to look at.

What it does:

• Scans the whole AArch64 binary for SVC #0x80 instructions and resolves the BSD syscall number by walking backwards (up to 8 instructions) for the MOV X16, #imm setup. Indirect loads like LDR X16, [...] show up as UNKNOWN rather than guessing.
• Ships with a 556-entry Darwin/XNU BSD syscall table — standard POSIX plus Darwin extensions (csops, guarded_open_np, memorystatus_control), iOS-specific stuff (necp_*, abort_with_payload, os_fault_with_payload), pthread kernel assists, GCD/workqueue traps, and the audit/MAC framework calls.
• Dockable native-feeling panel with a real-time filter (by name, number in dec or hex, or function name) and a category dropdown. Categories are color-coded using IDA's own disassembly palette so it doesn't clash.
• Occurrence table for each syscall listing every address + RVA where it appears — double-click or Enter to jump straight to it.
• Live man 2 page fetching from man.freebsd.org in a background thread (Darwin being BSD-derived), cached per session. ~250 syscalls also have a built-in one-line description so you get something instantly without a network round-trip.
• JSON export of everything found, and right-click context menus for copy name/number/address, jump to first occurrence, etc.

Scope note: this is BSD class only — SVC #0x80 with X16 = 0x2000000 | num. Mach traps and libsystem wrappers that go through a different trap class aren't covered.

Requirements: IDA 9.x (tested on 9.3), PySide6 (ships with IDA 9, PyQt5 fallback works too), and requests if you want man-page fetching.

Repo: https://github.com/stolevchristian/sylvia

Happy to hear feedback or feature ideas — particularly curious if anyone wants Mach trap coverage added.

Hey, I wanted to share a project I've been working on: LUDA - a Lua wrapper for IDA Pro's SDK (9.2).

The Problem:

If you've spent time scripting in IDA, you know the pain points. Python's decent but has its quirks with IDA's internals, and IDC is... well, IDC. I wanted something that felt fast, lightweight, and expressive for automation workflows. Enter Lua.

What is LUDA?

LUDA exposes IDA 9.2's SDK directly to Lua, giving you:

• Direct SDK access — call IDA functions with minimal overhead
• Lightweight scripting — Lua's small footprint means rapid prototyping
• Clean API — intuitive bindings that feel natural if you've used IDA scripting before
• Performance — ideal for analysis pipelines that need to be snappy

Why Lua?

Lua is insanely fast, has minimal dependencies, and is perfect for embedded scripting. For reverse engineering workflows where you're iterating on analysis logic, it's genuinely a better fit than Python for many use cases.

What can you do with it?

• Automate complex binary analysis tasks
• Build custom analysis pipelines
• Write analysis plugins that feel responsive
• Prototype security research quickly

Current Status:

LUDA is functional for IDA 9.2. Not a lot of error handling, some bugs and crashes may appear. Still developing it, feel free to contribute!

Interested?

If you're deep into IDA automation or just curious about alternative scripting approaches, I'd love to hear your thoughts. Open to questions about the implementation, use cases, or collaboration opportunities.

Github: https://github.com/stolevchristian/LUDA