Building DualSense Edge Studio:
Editing Controller Profiles Without a PS5

DualSense Edge Studio's button editor: a drawing of the controller with a line from each button to its function

The Problem: A Pro Controller Whose Settings Live on a Console

The DualSense Edge is Sony's "pro" controller: back paddles, swappable stick modules, adjustable trigger travel — and four on-board profiles you switch with FN + △ / □ / ✕ / ○. Each profile remaps buttons, reshapes the stick response curves and cuts the trigger range. The catch is where you edit them: on a PS5. The profiles are stored in the controller, but the only official editor is a menu on the console.

That's fine if the controller lives next to a PS5. Use it with a Mac, though, and there was no native way to touch those profiles at all. You could play with the controller, you just couldn't change how it played.

DualSense Edge Studio is the fix: a native macOS app that reads all four slots over a USB cable, lets you edit buttons, sticks and triggers in a proper UI, and writes the result back to the controller. No PS5, no browser. Like everything on this site, it was built in back-and-forth with Claude.

"The profiles already live in the controller. The console is just one way of talking to it — USB is another."

What It Does

Plug the controller in, open the app, and the sidebar fills with the four slots. Everything you change is a draft: nothing reaches the controller until you click Write to □ / ✕ / ○.

🕹️
Buttons
All 16 buttons remappable, back paddles included. Click the drawing, or press the target button on the controller itself.
📈
Sticks & Triggers
The 6 PS5 curves, intensity, dead zone, a free-form curve you drag by hand, and the usable range of L2/R2.
📡
Live Monitor
Gyro with a 3D controller, touchpad with two fingers and trails, every button, the raw input report and rumble.
🩺
Diagnostics
Measures stick drift and suggests a dead zone, tests circularity, shows the real trigger range, the 1000 Hz USB rate and firmware.
🗂️
Library, Backup & History
Profiles on the Mac, full 4-slot backups, and an automatic copy of every slot before it's overwritten — undo in one click.
💡
Hardware
Light bar, player LEDs, mute LED, each rumble motor and the adaptive-trigger effects, live while connected.

There's also a preset gallery (FPS, Battle Royale, Racing, Fighting, Sports, Accessibility), side-by-side profile comparison, a menu-bar icon with battery and the active profile, and JSON import/export compatible with the edge-config.com web editor, so libraries move freely between the two.

Talking to the Controller: 64-Byte Feature Reports

Over USB the Edge is a HID device (Sony's vendor ID 0x054C, product 0x0DF2), and the profiles travel as feature reports — fixed 64-byte packets where byte 0 is the report ID. One profile doesn't fit in 64 bytes, so each slot is split across three of them:

SlotReadWriteClear (0x68)
△ Default0x70–0x72never–
□0x73–0x750x602
✕0x76–0x780x613
○0x79–0x7B0x624

Inside those three parts the layout is wonderfully awkward. The profile name is UTF-16LE and doesn't fit in one part, so it starts in part 0 and spills into part 1 (40 code units in total). Part 1 also holds a 16-byte profile ID and the stick curves — except the right stick's curve is 6 bytes and only 4 fit, so the last two continue at the top of part 2. Part 2 has the trigger ranges, the 16-entry button table, the curve types, and the time the profile was saved, as a 48-bit millisecond timestamp.

The button table is the elegant bit: 16 positions, one per physical button, and each value says which function that button now performs. Identity (0, 1, 2 … 15) means "nothing remapped". Making the right paddle act as ○ is a single byte.

Two CRC32s, and a Magic Seed

The controller won't accept a profile unless it's checksummed — twice. There's a profile CRC covering the content of all three parts stitched together (170 bytes), and then each 64-byte report carries its own CRC in its last four bytes. That second one has a twist: it isn't computed over the report alone, but over the report with an extra byte, 0xA3, in front of it. Both have to be right for the controller to take the profile.

// Profile CRC: parts 0 and 1 (bytes 2–59) + part 2 (bytes 2–55) = 170 bytes
function profileCrc(parts) {
  const r = new Uint8Array(170);
  r.set(parts[0].slice(2, 60), 0);
  r.set(parts[1].slice(2, 60), 58);
  r.set(parts[2].slice(2, 56), 116);
  return crc32(r);
}

t[2].set(le32(profileCrc(t)), 56);

// Per-report CRC: seed byte 0xA3, then the report, stored in bytes 60–63
for (const a of t) a.set(le32(crc32(new Uint8Array([0xa3, ...a]))), 60);

Both are plain IEEE CRC32, little-endian. The whole protocol layer — slots, curves, CRCs, the input report — lives in one dependency-free file, proto.js, and the byte-by-byte map is written up in the repo's PROTOCOL.md.

Byte-Exact or It Doesn't Ship

Not every byte in those reports is understood. So the encoder never builds a profile from zeros: it starts from the original bytes read from the controller (kept as profile.raw), overwrites only the fields the app actually edits, stamps the time, and recomputes the CRCs. Anything unknown passes through untouched.

That made a strict test possible, and it became the bar for the whole protocol: read a profile the PS5 saved, re-encode it without changes, and compare. The result has to be the exact same bytes, with the same CRC. Then write a profile and read it back — again, identical. Only once both round trips matched on a real controller did writing go in.

"If you don't understand a byte, don't rewrite it. Carry it through, and prove the round trip is lossless."

A Native Layer That Says No

Writing to a controller's memory deserves guard rails, and the most important one isn't in the UI — it's in the native code. The Objective-C side only forwards feature reports 0x60–0x63 (the slot writes) and 0x68 (clear a slot); any other report ID is rejected before it reaches the device. The only output report allowed is 0x02 — lights, rumble and trigger effects, none of which are stored. Even if the UI had a bug, it couldn't talk the controller into anything else.

The Diagnostics tab: stick drift, circularity, trigger range, USB report rate and controller info
Diagnostics: drift with a suggested dead zone, circularity, the real L2/R2 range, the 1000 Hz USB rate and firmware info.

The Stack: Objective-C Underneath, a Web UI on Top

The app is two layers. src/main.m is a single Objective-C file: it opens the controller with IOKit HID, streams the input report up to the UI, performs the feature-report reads and writes, and owns the window, the menu-bar item, battery notifications and files. Everything else — the profile logic, the protocol, every screen — is plain HTML, CSS and JavaScript loaded in a WKWebView. No bundler, no npm, no dependencies. Building takes Apple's Command Line Tools and one ./build.sh, which produces a universal app for Apple Silicon and Intel.

The seam between them is a small message bridge: the UI calls Native.call(cmd, args) and gets a Promise back, the native side pushes events (status, input, error). And because that bridge is the only door, it's easy to fake: open web/index.html in a normal browser and native.js swaps in a simulator with sample slots and synthetic input. This is how the UI can be worked on without a controller on the desk — and every screenshot in the README was taken in simulator mode.

The live monitor: controller drawing, sticks, triggers, gyroscope with a 3D controller and touchpad
The live monitor, here running on the simulator's synthetic input.

Version 1.1 added nine languages — English, Portuguese, Spanish, French, German, Italian, Russian, Simplified Chinese and Japanese. The source strings are Portuguese and act as their own keys (T("…") in JS, L(@"…") in Objective-C), and the native side reads the very same translation files as the web UI, so menus, notifications and screens never disagree. A small script, i18n_check.py, flags any missing translation or mismatched placeholder. The release build is signed with a Developer ID and notarized by Apple, so it opens like any other Mac app.

Built with Claude

Same as every project here: I'm not a programmer. I'm someone who owns the controller, wanted to tune it from a Mac, and could describe exactly what the app should do. Claude did the heavy lifting on the code; I did the testing with a real controller on the desk — which, for a project that writes to hardware, is the part that can't be skipped.

The byte-exact round trip was the conversation that mattered. It turned "I think the protocol works" into a yes-or-no test, and every change to the encoder after that had to pass it again.

"When the target is hardware, 'it looks right' isn't a test. Same bytes in, same bytes out, is."

The Result

DualSense Edge Studio is free and open source (MIT), for macOS 12 Monterey or later on Apple Silicon and Intel. Download the notarized .dmg, drag the app to Applications, connect the controller with a USB cable and open it. Profiles can't be edited over Bluetooth — same as on the PS5.

Download and details: the project page · source and docs on GitHub.

DisclaimerAn independent project, not affiliated with Sony Interactive Entertainment. "PlayStation", "DualSense" and "DualSense Edge" are trademarks of Sony. Writing profiles changes the controller's memory; the △ slot and the firmware are never touched.