Developer Tools - James Montemagno https://montemagno.com/tag/developer-tools/ https://montemagno.com/content/images/2017/08/MonogramIcon_Orange_NoBuffer.png Developer Tools - James Montemagno https://montemagno.com/tag/developer-tools/ Hugo -- gohugo.io Sat, 21 Nov 2026 15:44:45 GMT 60 How I Got My Cadence Ready for iPhone Duo (Without Redesigning It) https://montemagno.com/upgrading-my-cadence-for-iphone-duo/ https://montemagno.com/upgrading-my-cadence-for-iphone-duo/ Sat, 14 Nov 2026 16:25:00 GMT

My Cadence has one job: put a big number on your screen so you can see your RPM while you're on the bike. I built it back in 2020 because Apple Fitness+ wouldn't connect to my cadence sensor, and it has become one of my top apps. These days it's a Swift app on iOS and a .NET MAUI app on Android.

I wanted My Cadence to look and feel great on iPhone Duo. Here is what a ride looked like on the Duo's big inner display before this work:

The old My Cadence layout during a ride on an open iPhone Duo. A small Connected status, a large RPM number, Stop Ride, and four small stats sit across the top of the screen, and the bottom of the screen is empty.
Before: a ride on the open iPhone Duo, captured on the simulator with a simulated ride. This is the old layout rebuilt with today's tools.

It works, but that is a whole lot of empty space! So how do you use all that room without ruining a simple app?

One thing up front: I don't have an iPhone Duo. Everything here was tested on the simulator, and this update isn't in the App Store yet. So, let's walk through the plan, the skills, the design, and the gotchas.

Start with a plan, then find a better one

I started with a written plan, and my first version was ambitious: a new "cockpit" look on every iPhone, built on top of a community toolkit. Then I brought in Apple's iPhone Duo preparation guide, and it changed the whole thing. Apple breaks the work into three steps:

  1. Run the App Resizability skill to scan your project.
  2. Fix what it finds, and inspect what automation misses.
  3. Test resizing on the simulators and tools Apple provides.

One line from that guide really stuck with me: "On the inner display, your app should look like a natural extension of its iPad layout." Keep that one in mind, because it pays off later!

Sticking with Apple's tools

Apple's App Resizability skill comes with Xcode. You can ask Xcode's coding assistant to "get my app ready for iPhone Duo," or export the skill if you use a different agent. I exported it and ran everything from VS Code with GitHub Copilot.

My first plan also pulled in Duology, a community set of skills and a fold linter for iPhone Duo. Once we had Apple's official tooling, I asked whether we still needed any of it, and I decided to stick with Apple's tools only. The most useful part for My Cadence was the checklist, and fewer moving parts felt right for a simple app. If you're building something new for Duo, it's still worth a look.

So what did the audit find? Honestly, not much! My Cadence wasn't sizing itself from the main screen, checking for specific devices, or making layout choices from device orientation. It did turn up the Ride and Scenic player screens choosing their layout by comparing width and height, plus catalog thumbnails that could widen their grid column.

A clean audit isn't the finish line, though. Apple says so in the guide: "The skill finds most issues, but not all of them." Most of the problems in the rest of this post came from reading Apple's docs closely and from actually running the app.

"We don't need crazy colors"

While I was working on the plan, I started thinking about new ideas for what the app could do with all that extra screen. It's hard to picture a layout from a table in a Markdown file, so I asked GitHub Copilot in VS Code to generate some image mockups for me. Here is what came back:

An AI-generated design concept board labeled Ride Cockpit, showing dark teal screens with glowing circular gauges on closed, open, and book-style iPhone Duo devices.
An AI-generated design concept that I rejected. This is not the app.

Pretty wild, right? It's a full "Ride Cockpit" concept, with dark teal screens and a glowing gauge wrapped around the RPM on the closed, open, and book-style Duo. It even came with a tagline: "Same ride. More room."

It's cool, but it isn't My Cadence. The whole point of the app is a big, simple number that you can read while you're riding, and it's supposed to feel like it belongs on your iPhone. So, here is what I said back: "We absolutely want to keep with our very simple design that we have today in the app, we don't need crazy colors or anything like that, we want just super native look and feel for light and dark mode."

Copilot updated the plan and generated a new set of mockups in both light and dark mode. This round looked a lot more like the app I know:

An AI-generated design concept board showing a simple native layout in light and dark mode on closed and open iPhone Duo devices, with a large RPM number, a small cadence line, stats, and a red Stop Ride button.
The revised AI-generated design concept. It's still a mockup, not the running app.

There's the big number, the familiar cards, and a regular Stop Ride button, plus a small, quiet line for live cadence. That became the rule for the project: same app, more room. There are no gauges, gradients, or new color themes, and my existing Pro customizations keep working.

Asking for pictures this early was so useful. No app code had changed yet, so it was really cheap to look at an idea, say "nope," and try again. It's a lot easier to react to an image than to a paragraph describing one!

One thing to be aware of: generated mockups can make things up. These drew approximate system controls and even little camera icons, and that doesn't mean I wanted any of that in the app. I used them to pick a direction, not as a spec. The actual layouts came from Apple's guidance and from running the real app.

"Something much more interesting"

The first working version kept everything simple and added a small gray cadence line. It worked, but with the Duo open I wanted more from all that space. My feedback was that it needed "something much more interesting," like a live chart right alongside the stats.

So now it has one:

My Cadence on an open iPhone Duo during a ride. A connected status and large RPM number fill the left side. Stop Ride, a large live cadence chart, and four stat tiles fill the right side.
After: the open iPhone Duo with the new live chart, captured on the simulator with a simulated ride.

The big chart is the same chart and colors you already see in ride details, and it's free for everyone. The number and stat tiles get bigger too.

Here's the nice side effect: the iPad gets this layout too! I have a lot of iPad users, and they had the same empty screen.

Two iPad screenshots of My Cadence during a ride, side by side. On the left, the old layout has the RPM, Stop Ride, and stats at the top with most of the screen empty. On the right, the new layout has the same RPM and controls, a large live cadence chart filling the middle, and stats at the bottom.
Before on the left, after on the right. Both are real captures on the iPad simulator with a simulated ride. The before is the old layout rebuilt with today's tools.

What about a regular iPhone? It keeps what already worked: the full-size number and the stats, with a small trace added.

My Cadence on a regular iPhone during a ride, with a large RPM number, a red Stop Ride button, a small cadence line, and four stats in a row.
A regular iPhone still looks like My Cadence. Captured on the simulator with a simulated ride.

Light and dark mode come straight from the system, just like they always have:

My Cadence in dark mode on an open iPhone Duo held tall, with the RPM number on top, then Stop Ride, a live cadence chart, and four stats along the bottom.
Dark mode with the Duo open and held tall, captured on the simulator with a simulated ride.

The gotchas

Apple's split container would have hidden the controls

The plan was to use Apple's native layouts first, and for Ride and the Scenic player that meant ArrangementView. Then we read the split style documentation closely: "When someone is holding a closed iPhone Duo in landscape orientation, the split arrangement only shows the primary view."

For My Cadence, that means you'd lose either the number or Start/Stop and your stats. That isn't okay on a bike! We're going by Apple's docs here, since I didn't see that pose for myself before making the call. So we wrote a small layout of our own for those two screens, and History still uses Apple's native split view.

The closed display in landscape needed the help. Here is the old layout, with its cut-off stat labels and a wrapped Stop Ride button:

The old My Cadence layout on a closed iPhone Duo in landscape. The RPM number fills the middle, Stop Ride wraps onto two lines, and the stat labels are cut off to M, R, and TI.
Before: the old layout on the closed Duo, rebuilt with today's tools and running a simulated ride.

And here is the new one, with everything still on screen:

The new My Cadence layout on a closed iPhone Duo in landscape. The RPM number is on the left. Stop Ride, a small cadence line, and four fully labeled stats are on the right.
After: RPM, Stop Ride, sensor status, and all four stats, captured on the simulator with a simulated ride.

My takeaway: go native first, right up until native hides something people need.

The number that got cut off

In an app about one big number, this one hurt. The first pass cut off the RPM on the closed display in portrait. Copilot noticed and made a quick fix at the end of its run, but that fix only stopped the clipping by making the number noticeably smaller.

When I looked at it, I said it should be "more like we have today." The next pass gave the number more of the screen, and it's back to full size:

My Cadence on a closed iPhone Duo in portrait during a ride, with a large uncut RPM number, a red Stop Ride button, a small cadence line, and four stats in a row.
The fixed closed display, captured on the simulator with a simulated ride.

A layout can pass every check and still be wrong for your app. You have to look at it!

Your video might not survive a fold

My Cadence has Scenic rides, which are first-person cycling videos you can ride along with. There were two problems here. The player compared its address against one that always differed, so any view update could reload the video. The screen also swapped between two different layouts, and that destroyed the player whenever it changed.

Now there's one stable player. On the simulator, the video kept playing through a fold, moving from its intro into the ride footage with no new page load. If your app embeds a web player, go test this one! The catalog also uses the room a lot better now, with four columns when the Duo is open instead of one giant card:

The My Cadence Scenic Rides catalog in dark mode on an open iPhone Duo, with a banner, search field, scenery filters, and a row of four video thumbnails.
The Scenic catalog on the open Duo in dark mode, captured on the simulator.

The little ones

A few smaller bugs showed up once we started really testing:

  • A missing Back button. A collapsed History detail had no way back, so selecting a ride with the phone open and then closing it left you stuck. Test that exact path if you use a split view!
  • Ride charts that stopped short. They had a fixed height, so on a big iPad the chart stopped about halfway down the screen. Now they grow to fill the space.
  • "1 rides" and "12 / 1 rides." Yes, really. It had nothing to do with Duo, but my achievements screen now reads "1 ride" and "12 rides."

Here is where History ended up, with the list and details side by side when the Duo is open:

My Cadence ride history on an open iPhone Duo, with a monthly activity chart and ride list on the left and the selected ride's stats and cadence chart on the right.
History on the open Duo with sample rides, captured on the simulator.

Testing without a Duo

Step three of Apple's guide is testing, and the iPhone Duo simulator is Apple's recommended way to test the full experience. One thing to be aware of: you change poses with the Closed, Partially Open, Open, and Rotate controls in Device Hub. Those controls are the only way to do it, so testing takes a while. My Mac even locked in the middle of one run, and that was the end of folding until I got back to it!

The simulator also has no Bluetooth, so we added a debug-only simulated cadence to ride with. With that, one ride kept going from open wide, through book, to open tall.

Wrapping up

If you're getting your own app ready, start with Apple's guide and treat the skill as a great checklist. Then put the app on the simulator and look at it, because the things that mattered most for My Cadence came from looking at it. And don't be surprised if your iPad app gets better along the way.

The update isn't in the App Store yet, but you can check out My Cadence today. It's the same simple app with a whole lot more on screen. Happy riding!

]]>
Introducing Clipboard Next for Mac and Windows https://montemagno.com/introducing-clipboard-next-mac-windows/ https://montemagno.com/introducing-clipboard-next-mac-windows/ Fri, 13 Nov 2026 18:30:00 GMT

When we demo, we're often trying to remember every command we need to enter. For Ignite, we have a series of .NET MAUI DevFlow commands to run, and remembering all of them just isn't going to happen! Sometimes you don't need to memorize anything. You just want the next item ready on your clipboard.

That is why I built Clipboard Next, a small, free, open-source app for Mac and Windows that lines up your commands, code snippets, and prompts so you can keep moving through your demo.

Here is a quick look at the idea:

A short, silent animation illustrating the command queue, terminal, and progress badge. You can also see the live animated demo on the Clipboard Next website.

Queue it up, then just paste

Add your snippets in the order you want to present, enable paste detection, and press Start. The first item lands on your clipboard. Paste with Command-V on Mac or Ctrl+V on Windows, and Clipboard Next copies the next item after a configurable delay. No trip back to your notes between commands.

Already have a Markdown demo script? Import it! Preview the code blocks, split them into individual lines or keep multiline blocks together, and optionally include blockquoted prompts.

A few little details make this useful beyond a straight list of commands:

  • Keep your place: an optional floating progress badge stays visible without taking keyboard focus.
  • Go off script: pause, resume, go back, skip ahead, or start from a selected snippet.
  • Copy something else: the queue pauses rather than overwriting the different text you just copied.
  • Keep it local: no account, telemetry, or cloud sync. Your queue stays on your device.
Clipboard Next on Windows with the third of seven snippets selected, pause and navigation controls, and a floating 3/7 progress badge.
The Windows queue and floating badge keep track of your place while presenting.

One thing to know: detection observes the paste shortcut, not whether the destination successfully pasted. Test your terminal or editor before presenting. The app doesn't run commands or press Enter, but multiline text can still execute when pasted into some terminals, so review your snippets.

Get Clipboard Next

On Mac, install with Homebrew or grab the signed, notarized app from GitHub Releases. You'll need macOS 14 or later and Input Monitoring permission for automatic advancement.

The Windows app targets Windows 11, with distribution through the Microsoft Store. Check the download page for release availability.

A little bit under the hood

The Mac version was pretty straightforward: Swift and SwiftUI for a native menu bar app, then Homebrew for installation. The Windows version is a native C#/.NET 10 app built with WinUI 3 and system tray controls. The queue logic was ported rather than shared, but both versions use a compatible queue-file format. If you're curious about how it works, check out the source on GitHub!

]]>
Restore SwiftUI Menu Icons on macOS 27 with One Line https://montemagno.com/restoring-tiny-clips-menu-icons-macos-27/ https://montemagno.com/restoring-tiny-clips-menu-icons-macos-27/ Sun, 08 Nov 2026 16:00:49 GMT

Tiny Clips had a nice little dropdown full of icons on macOS 26. On macOS 27, most of those icons disappeared from its SwiftUI MenuBarExtra menu. The labels were still there, but the menu looked quite different.

If your app uses symbol images in SwiftUI menus, you might be seeing the same thing. Before you start replacing your SF Symbols or building an AppKit bridge, check the menu's label style!

Tiny Clips menu on macOS 27 with text-only Screenshot, Copy Text from Region, Record Video, Studio Recording, and Record GIF items.
Before: menu items without visible icons.

Where did the icons go?

This is an intentional default change, not necessarily a missing image or a broken Label.

In the macOS 27 release notes, SwiftUI entry 170480710 explains that menu bar menus and macOS context menus now show a reduced set of images:

  • Symbol images are hidden by default in most contexts.
  • Non-symbol images remain visible, according to the SwiftUI entry.
  • Common system items such as Settings, Share, and Print still get default visible images.

That last detail explains why a menu can look inconsistent: some icons survive even when most of your app's symbols disappear.

Apple recommends reviewing which items actually benefit from images, particularly items representing an object or concept rather than an action. You don't have to opt every menu back in. However, when you do want to preserve an existing icon-driven menu, SwiftUI already has the modifier you need.

The one-line SwiftUI fix

Use .labelStyle(.titleAndIcon) on the content inside MenuBarExtra.

The Tiny Clips implementation PR adds the modifier in mac/TinyClips/TinyClipsApp.swift. The existing content view becomes:

MenuBarContentView(captureManager: captureManager, sparkleController: sparkleController)
    .labelStyle(.titleAndIcon)

That is the whole code change: one added modifier!

Applying the style to the content view sets it for the labels within that hierarchy, rather than changing label styling across the entire app. In Tiny Clips, that scope includes submenu labels and recent-capture labels with thumbnails or symbol fallbacks. It doesn't create images for text-only items.

There is no AppKit bridge, private API, new dependency, or macOS version branch. The existing actions, keyboard shortcuts, and platform guards stay unchanged.

Tiny Clips menu on macOS 27 with camera, text-recognition, video, layers, and image icons beside the capture options, plus icons for folders, recent captures, library, and settings.
After: icons visible alongside the menu labels.

There are the icons!

Does this raise the minimum macOS version?

No, not for Tiny Clips. labelStyle(_:) is available from macOS 11.0, and .titleAndIcon is available from macOS 11.3. Tiny Clips already supports macOS 15.0 and newer, so this change doesn't need an availability check.

Using AppKit instead?

If you create NSMenuItem instances directly, AppKit has a separate preferredImageVisibility property on macOS 27 and newer:

if #available(macOS 27.0, *) {
    menuItem.preferredImageVisibility = .visible
}

Here, menuItem is your existing NSMenuItem. This is the AppKit option, not an extra step for SwiftUI. AppKit's release notes also describe SDK-linkage-dependent image visibility; don't apply those rules to SwiftUI's separate release-note entry.

For a SwiftUI MenuBarExtra like Tiny Clips, start with the supported label-style modifier. A small, scoped change beats replacing your menu just to ask for its icons back.

Happy coding.

]]>
Introducing Tiny Clips Studio: Screen Recordings You Can Keep Editing https://montemagno.com/introducing-tiny-clips-studio/ https://montemagno.com/introducing-tiny-clips-studio/ Tue, 03 Nov 2026 22:00:00 GMT

You finish recording a demo, play it back, and notice that your camera bubble is sitting right on top of the button you were explaining. Or the recording looks good, but you want to zoom in on one little detail and switch to a different layout halfway through.

Trimming the beginning and end isn't going to fix that!

Today, I'm introducing Tiny Clips Studio (Preview) for macOS and Windows. It adds an editable recording workflow to Tiny Clips, the little menu bar and system tray app for screenshots, videos, and GIFs.

The idea is pretty straightforward: record now, choose the look afterward. Keep your screen and camera separate, arrange them in Studio, and create the final MP4 when you're ready to share. Want a different look later? Reopen the project and change it.

Here is a quick look at Studio in action:

A 45-second overview with music and no narration, showing editable screen and camera layers, layouts, zooms, cuts, and export. It combines real editor controls with illustrative compositions; preview capabilities vary by platform.

Download Tiny Clips for macOS and Windows, then enable Settings > Studio > Tiny Clips Studio (Preview).

Let's take a look at what had to change in the recording pipeline, how two native apps agree on a project, and some of the decisions that went into building the editor.

From a recording to a project

The biggest change in Studio happens before you ever touch an editing control.

An ordinary Tiny Clips recording produces a finished video. On Windows, the camera and overlays are drawn into the frames while recording. On macOS, the screen and camera are captured separately, but the normal workflow combines them after recording. Either way, by the time you start trimming, you're working with one flattened picture.

Studio takes a different path. A Studio recording keeps:

  • The screen recording, without the camera composited on top.
  • A separate camera recording, when you include your webcam.
  • Cursor and click timing data, for features such as zoom suggestions.
  • Project settings, describing the layout, styling, and edits.

Instead of immediately combining everything, Studio opens those pieces in an editor. The final composition is rendered when you export.

That is what makes moving the camera after recording possible. It isn't trying to erase a camera bubble from an existing video. The screen underneath was kept in the first place.

Screen recording, optional camera recording, and click and cursor data feed an editable Studio project. Layouts, scenes, zooms, and cuts are applied before exporting an MP4, while the project remains editable.
The Studio workflow: keep the ingredients separate, edit the project, and render the video when you're ready to share.

One important distinction: Studio needs those original pieces. It doesn't magically separate the webcam from an older, flattened MP4.

Give the recording a look, then tell the story

You can start with a screen-only layout, add a camera bubble, put the screen and camera side by side, or switch to camera only. Change the background, padding, and rounded corners, then adjust the camera's size, position, and shape.

The real Windows Studio editor in light mode, with the screen preview and camera bubble on the left, Scene layout choices on the right, and editing lanes below. Color bars and frame numbers are synthetic test footage.
The real Windows Studio Preview editor, captured in an isolated test host. The color bars and frame markers are synthetic clips used to check composition and timing, not a UI mockup.

For a quick demo, that might be all you need: record, frame it nicely, trim, and export. No need to turn every clip into a production.

But the layout doesn't have to stay the same for the entire video. Scenes let different parts of a recording use different arrangements. For example, you could open with the camera, switch to the screen with a small camera bubble for the walkthrough, and finish side by side. Transitions can be instant or animated.

There are also timeline tools for zooms, cuts, and speed changes. Zoom in on the setting you're explaining, cut out a pause, or speed through a repetitive step. Zooms can focus on a fixed point or follow the pointer when that recording includes pointer data. Click-based suggestions give you a starting point that you can adjust rather than committing you to an automatic edit.

A cropped Windows Studio timeline in dark mode. Separate lanes show three scenes, two zooms, two cuts, faster and slower speed segments, and trim handles.
A closer look at the actual timeline: scene layouts, zooms, cuts, and speed changes each have their own lane. Cropped from the test project's editor window.

This is still a preview, and the two platforms aren't identical in every detail. Audio controls, camera background effects, and playback behavior have platform-specific limitations. The Studio development pull request tracks the implementation and known issues; the shared project design isn't a promise that every preview control behaves identically on both systems.

One design, two native implementations

For the developers out there, this is where the project gets interesting.

Studio wasn't built by putting the same web editor inside both apps. The Mac implementation uses Swift and SwiftUI, with AVFoundation and Core Image handling composition and rendering. Windows uses C# and WinUI 3, with Direct3D/Direct2D rendering and Media Foundation for video processing.

Different stacks, but they need to agree on what a project means.

A shared project format, layout math, and golden test fixtures guide two native implementations. macOS uses Swift, SwiftUI, AVFoundation, and Core Image. Windows uses C#, WinUI 3, Direct3D, Direct2D, and Media Foundation. Both provide preview and MP4 export.
Architecture at a glance. The shared layer is a specification and test data, not a common UI runtime; preview capabilities still vary by platform.

The foundation is a shared project format and rendering specification. Layout positions use normalized coordinates rather than assuming a particular recording resolution. Edits refer to the source recording's timeline, and a time map handles the relationship between that timeline and the exported video after cuts and speed changes.

Why does that matter? Cutting out five seconds shouldn't require rewriting every zoom and scene that comes after it.

The layout resolver takes a project, a time, and a canvas size, then calculates what belongs in that frame. There is a Swift implementation and a C# implementation, checked against the same shared fixtures. The time mapping and zoom-suggestion logic use shared fixtures too.

That gives both implementations concrete examples to agree on, rather than relying on two screenshots that look roughly similar. It doesn't guarantee interchangeable projects or pixel-identical exports, but it makes the common rules testable.

Some of the most useful changes weren't rendering features

The development history starts in early October and includes plenty of work on renderers, exporters, and timelines. It also records the smaller decisions that shape what using Studio actually feels like.

For example, an early version had an "After recording" setting and a separate "Record for Studio" choice. That became one explicit entry point: Studio Recording... on the Mac and a Studio tile on Windows. Ordinary Video stays ordinary Video.

The inspector changed too. Instead of putting eleven sections in one long scroll, Studio uses a rail that opens one panel at a time: Scene, Background, Screen, Camera, Zoom, Cut, Speed, Audio, and Project. Selecting a zoom on the timeline brings up its controls. Dragging the camera opens the Camera panel.

The Windows Studio Camera inspector, with size, corner position, horizontal and vertical offset sliders, and a Circle shape selection. The adjacent rail switches between Scene, Background, Screen, Camera, Zoom, Cut, Speed, Audio, and Project.
The Camera panel and inspector rail, cropped from the running Windows editor. One set of controls at a time, instead of one long list.

Those aren't flashy export features, but they save you from hunting through a wall of sliders.

Testing also had to go beyond compilation. One Windows inspector issue survived builds and unit tests because the problem only appeared when the actual window was constructed: a referenced UI style didn't exist. Opening and exercising the real window caught what the model tests couldn't.

The work includes shared data tests, rendered-frame checks, export checks, and Windows UI Automation. A build passing and an editor being usable are different questions, and the development notes deliberately distinguish what was compiled, what was checked automatically, and what someone actually tried.

Keep the project, not just the MP4

An export is the video you share. The project is what lets you come back and make another version.

Studio manages projects inside the app, but you can also save a project as a folder containing its recordings and a .tinyclips project file. Opening that file imports a copy as a new draft, leaving the saved folder alone.

A Studio project can produce a flattened MP4 for sharing or a saved folder containing a .tinyclips file and separate recordings for future editing. Save the folder outside app-managed storage. Pinning a project prevents automatic cleanup but is not a backup.
Two different things to keep: the MP4 you share and the project folder you can edit again. Pinning a managed project is not the same as saving an independent copy.

There is an important storage trade-off here: keeping editable recordings takes more space than keeping only the finished MP4.

By default, exported projects are eligible for cleanup after 30 days without use, with a 10 GB limit for cleanup-eligible projects. Drafts and projects marked Keep this project are protected from automatic cleanup. Those settings are adjustable.

Keep this project protects against Studio's cleanup; it isn't a backup. In particular, Windows stores its managed projects in the app's data folder, which can be removed when you uninstall or reset the app. Save a project folder somewhere you keep your work if you want to retain it independently of the installation.

And once Studio has cleaned up the source files, the exported MP4 still plays, but those separate editable layers are gone.

Try Studio Preview

Studio Preview is included in the new store releases for macOS and Windows. There is no separate Pro gate for Studio, and it is off by default.

To get started:

  1. Update Tiny Clips. You can find the downloads and store links at tinyclips.app.
  2. Open Settings > Studio.
  3. Turn on Tiny Clips Studio (Preview).
  4. On macOS, choose Studio Recording... from the menu bar menu. On Windows, choose the Studio tile in the tray menu.
  5. Record a short demo, arrange it in Studio, and export an MP4.

If you just want your usual recording workflow, keep using Video. Turning Studio on doesn't turn every video recording into a Studio project, and leaving it off keeps the ordinary workflow unchanged.

Explore the design and source

Want to dig into how it works? Here are a few useful places to start. The implementation links below point to the revision used for this write-up, while the pull request tracks ongoing preview work.

The diagrams are available as editable Excalidraw files too: recording workflow, native architecture, and projects versus exports.

Give Studio a try with a short recording, move the camera somewhere else after you've finished, and export a second version. That is the idea in one little experiment.

If something doesn't work as expected, or you have an idea that would make recording demos better, open an issue in the Tiny Clips repository. I'd love to hear what you create with it.

]]>
Paste JSON as Code with quicktype.io in Visual Studio https://montemagno.com/paste-json-as-code-with-quicktype-io-in-visual-studio/ 5a78ad62da32ce0022cbd5f6 Mon, 05 Feb 2018 21:00:00 GMT

quicktype! Yes that quicktype that I blogged about late last year on how to convert JSON to C# classes in the browser. I am back talking about it again because they have made tons of great enhancements and just today released a new extension for Visual Studio 2017! I should mention here that all of this is FREE.

PasteAsCode

Watch Now, Questions Later

Want to see it in action? Checkout my short video overview:

Doesn't VS Do This?

It is true that Visual Studio has a Paste JSON as Classes feature, but it basically does the bare minimum. quicktype will automatically add in JsonProperty names, has enhanced partial classes, better names on parameters, fills in a full class and namespace, and even adds helper classes for you so you don't have to write boiler plate code.

Here is a good example of the power of quicktype. Let's take the Azure Cognitive Services Text Analytics JSON that is returned from the RESTful call.

It is pretty complex JSON with mutliple classes and arrays. If I use the "Special Paste" we do get C# classes back, but they aren't very pretty.

I now have to go through and fix all of the parameter and class names and add in JsonProperty attributes to the tops.

Now let's see the quicktype version:

Now we are talking! Look at those pretty classes and parameters!

Alright, that is enough show an tell for today. Go grab the extension and tell them Motz sent you on their community Slack!

This is NOT sponsored content. I do know the awesome quicktype team and was given early access to the extension. I just believe this is an awesome tool developers should have

]]>
Convert Json to C# (and More) with quicktype https://montemagno.com/convert-json-to-any-language-with-quicktype/ 59bfff08cb369f002e34f0d2 Mon, 18 Sep 2017 18:30:00 GMT

How often do you run into the situation where you are reading data from a json file or hitting a RESTful endpoint and pulling down a huge json file that you then need to deserialize? I bet pretty often as I know I do all the time. The next issue of course is that you have this bug json file, but you need to generate the actual data types, POCOs, inside of your C# code. This can be extremely tedious if you try to do it by hand and other websites give you lack luster C# files where you have to add in JsonProperty attributes, Serializers, and Converters. Well not any more with quicktype.io, which just launched today.

QuickType

What is quicktype?

When you head to quicktype.io you are greeted with a nice and friendly layout where you can input your json on the left and output to any language on the right. The site gives you some very nice default json types such as reddit and a pokedex to get started and then you pick what language:

Quicktypelanguage

Once you select your language it will remember it for future use, but they already support C#, TypeScript, Go, Java, Elm, and Swift in addition to a Schema and Simple Type output.

At any point you can just delete the json that is displayed and enter anything yourself. Modifying the Top-level type will update the code with whatever you want the base class to be. #MindBlown

Who is it by?

Awesome amazing people that I have worked with for many years. Mark Probst and David Siegel have been working on this project for some time now and have been developing it completely in the open on GitHub. I have to tip my hats as they have solved a problem that just about every developer runs into on a daily basis.

quicktype in Action

]]>