Recordly — a free, open-source screen recorder that auto-zooms, smooths and motion-blurs the cursor, then frames, captions and exports an MP4 or GIF on your own machine

• Recordly

  This page

  PricingRecordly leads

  • Free, with the whole feature set in the shipped builds — no trial timer, no watermark and no paid tier to unlock
  • AGPL-3.0: use, modify, redistribute and self-host it, and if you run a modified version as a network service you must publish your changes under the same licence
  • Money reaches the project through optional donations and third-party sponsors rather than through limits inside the app
  • Packaged installers are published on the project’s releases page, and an Arch AUR package exists for Linux users

• Screen Studio

  PricingRecordly leads

  • Sold as a subscription, billed monthly or yearly, with all features on both plans
  • There is no free tier — you download the app and a licence tied to your account unlocks it
  • Shareable links are part of the paid plan rather than a free extra
  • Legacy one-time licences are supported and handled through the account area

• CleanShot X

  PricingRecordly leads

  • Two shapes: a one-time purchase for the Mac app that includes a year of updates, or a per-user subscription
  • The one-time tier carries a small cloud allowance; unlimited storage, custom branding and team controls belong to the subscription
  • Renewing the one-time purchase for another year of updates is optional and priced separately
  • There is no free trial — a money-back window is the try-before-you-buy route

• OBS Studio

  PricingRecordly leads

  • Free and open source, with no paid tier, no account and no upsell inside the product
  • Donations and sponsors fund the project
  • Plugins are free too, though you are the one who finds, installs and maintains them

1. Recordly — official site
2. Recordly — source repository
3. Recordly — README, system requirements and limitations
4. Recordly — download builds for macOS, Windows and Linux
5. Recordly — AGPL-3.0 licence and its name restriction
6. Recordly — extension API
7. Recordly — cloud sharing and the self-hosted share service
8. Recordly — blog
9. Screen Studio — official site
10. Screen Studio — plans
11. CleanShot X — official site
12. CleanShot X — plans and licence terms
13. OBS Studio — official site
14. OBS Studio — downloads

Free tier

Yes

Pricing summary

The honest version of the pricing story is that there is no pricing page, because there is nothing to buy. The application ships with its full feature set — recording, the timeline editor, cursor controls, framing, webcam overlay, auto-captions, MP4 and GIF export — and none of it is gated behind a licence key or a subscription. The project’s own copy says it is free and will stay that way, and the AGPL-3.0 licence is what makes that a commitment rather than a promise: anyone can fork it, and the reciprocal clause means a modified version offered as a network service has to publish its changes. What that licence also asks for is worth knowing before you build on it. It permits commercial use of the output — a demo video you make with Recordly is yours — but it forbids shipping the app under the Recordly name or branding, and it requires attribution in the user-facing interface and in the repository if you reuse the code. Money reaches the project through optional donations, third-party sponsors credited on the site, and a Ko-fi link, not through the product. If you want to pay something, that is where it goes. Two things follow from free-and-not-company-backed that are worth planning around: there is no support contract behind it, and platform gaps are community-reported rather than guaranteed to be fixed on a schedule — the README documents them plainly instead of hiding them. Treat “free, with no paid tier” as the stable part and confirm the licence wording and the sponsorship situation on the official site and the repository as the project evolves.

Reviewed on 24 September 2026 · Recordly — official site

• Recording a display or a single window

  You choose an entire display or one application window, pick microphone and system-audio options, record, and stop — which drops you straight into the editor rather than into a file browser. On macOS and Windows the capture runs through native backends (ScreenCaptureKit and Windows Graphics Capture) rather than a generic screen grab, and how well the real cursor can be hidden follows the same split.

• Auto-zoom suggestions and manual regions

  The editor proposes zoom regions from where the cursor went and what it did, and you can also drop manual zoom regions wherever you want the attention. Either way the movement between zoom levels is animated rather than cut, which is the single biggest thing that separates a demo that reads as designed from one that reads as raw screen capture.

• Cursor polish after the take

  The cursor is re-rendered as an overlay, so its size, smoothing, motion blur, click bounce and sway are all editable once the recording exists. There is a loop mode for the cursor path so a clip can end where it started — useful when the export is a GIF that autoplays — and the overlay uses macOS-style cursor assets for a cleaner look.

• A webcam bubble that reacts to the video

  Webcam footage becomes an overlay bubble with preset or custom placement, mirroring, size, margin, roundness and shadow controls. The detail worth having is zoom-reactive scaling: the bubble grows and shrinks with the zooms so it stays proportionate instead of sitting there at a fixed size while the screen beneath it moves.

• Timeline editing built for screen content

  Trims, speed-up and slow-down regions, zoom regions, annotations, extra audio regions and crop-aware edits live on a drag-and-drop timeline, and the whole editor state saves into a .recordly project file so a recording can be reopened and re-cut rather than redone. Text, image and figure annotations cover the callouts a walkthrough usually needs.

• Framing and backgrounds

  The recording is composed inside a frame with wallpapers, custom uploads, solid colours or gradients, plus padding, rounded corners, background blur, drop shadows and aspect-ratio presets for the shape you are publishing to. The same scene logic that draws the preview is what renders the export, so what you approve in the editor is what lands in the file.

• Auto-captions you can edit

  Captions are generated from the recording’s audio with a Whisper model that the app downloads and runs locally, then presented as an editable caption list on the timeline with style and layout controls. Caption sidecar files can also be written out at export, which is what makes the same clip usable on a platform that wants its own subtitle track.

• MP4 and GIF export

  Two outputs from one recording: MP4 for the thing people watch, and GIF for the thing people scroll past — with quality selection, GIF frame rate, a loop toggle, size presets and explicit output dimensions. Looping the cursor path and exporting a GIF is the combination that produces a README or changelog clip that does not visibly jump at the restart.

• Extensions for the parts it does not ship

  A permission-gated extension API runs inside the editor renderer: extensions can draw into the render pipeline, react to playback and export events, register cursor effects, add settings panels and contribute packaged assets such as frames, wallpapers and cursor styles. It is a community system rather than a commercial marketplace, which means quality varies and the documentation is the repository.

• Sharing, documented and honest about its state

  The export menu offers a share link, which renders an MP4, uploads it to a share service and returns a viewing page with timestamped comments, reactions, captions, password protection, expiry and a private library. The important caveat is stated in the project’s own documentation: shipped builds point at a locally hosted endpoint and production integration is planned rather than live. The service is open source and self-hostable if you want to run it yourself.

1. 1

   Record the window, not the desktop

   A single application window gives you far less to hide: no dock, no notifications, no second monitor edge, and the framing work in the editor starts from something intentional. If you do need the whole desktop, clear it first — removing a stray browser tab in the editor is possible, but removing it from the recording is not.

2. 2

   Set up both audio sources before the first take

   Recordly captures microphone and system audio together, and the platform rules differ: native support on Windows, a ScreenCaptureKit-dependent path on recent macOS, and PipeWire for system audio on Linux. Testing both on a ten-second take is much cheaper than discovering the voice track is silent after a five-minute walkthrough.

3. 3

   Speak through the pauses

   Screen recordings get long because people narrate the obstacles they are avoiding. Decide what the clip is proving, do that one thing, and stop — trims are easy in the editor, but a tighter take always cuts better than a tight edit of a loose one.

4. 4

   Let the automatic zooms do the first pass

   Accept the suggested regions initially and watch the result at normal speed before changing anything. Most of the value comes from the movement between zoom levels, and hand-placing every region before seeing that in motion usually means redoing them anyway.

5. 5

   Fix the cursor last, not first

   Size, smoothing and motion blur are applied to the overlay rather than baked into the capture, so the cursor pass is cheap and reversible. Do it after the timeline is settled — a cursor tuned to one cut is tuned to the wrong clip as soon as the cuts move.

6. 6

   Style the frame for where it is going

   Pick the aspect ratio first, because it constrains every zoom and every annotation placement after it. A clip destined for a docs page and one destined for a vertical feed are different recordings even when the content is identical, and the padding, blur and shadows that look generous in one look cramped in the other.

7. 7

   Generate captions, then read them

   The auto-captions come from a local Whisper model, which means they are good at ordinary speech and predictably wrong on product names, acronyms and anything else you invented. Editing the caption list is far faster than typing it, but it is not a pass you can skip if the clip is going in front of people outside the team.

8. 8

   Export the MP4, then a looped GIF

   The MP4 is the artefact; the GIF is for the inline slot where nobody clicks play. Exporting the GIF with the cursor loop enabled gives a clip that restarts invisibly, and saving the .recordly project before you do means the next platform version is an edit rather than a re-record.

• Designers and product managers shipping a walkthrough

  A feature announced in a changelog lands better as sixty seconds of the interface doing the thing than as three paragraphs describing it. The auto-zoom, the framed background and the caption pass are exactly the work that usually turns this into a "next sprint" task, and here they are close to free.

• Developers recording a bug reproduction

  A bug report with a video in it gets fixed faster than one with a paragraph in it, and the recording side of this takes no setup beyond installing the app. The cursor controls matter more than they sound like they should: a repro clip is only useful if the viewer can see where the pointer clicked.

• Teams producing onboarding and help content

  Short, consistent, captioned clips are the format that documentation and support libraries actually want, and a local-first recorder means internal screencasts of internal tools do not have to be uploaded to somebody else’s cloud to be produced.

• Open-source maintainers and indie makers

  A GIF in the README is the highest-leverage asset a small project has, and the combination of free, Linux support, GIF export and a cursor loop covers the whole job without a subscription. The copyleft licence is a bonus rather than an obstacle for people already living in that world.

• Course and tutorial creators on a budget

  Per-lesson editing is where tutorial production time goes, and doing the zoom and cursor pass automatically is what makes a lesson recordable in one sitting. Captions that can be exported as sidecars are the accessibility pass as well as the retention one.

• Windows and Linux users who keep getting sent Mac-only advice

  Most of the polished-demo tooling in this category assumes a Mac. Recordly is the only entry in its comparison set that covers Windows and Linux with the same feature set, and the README is unusually candid about where those platforms fall short instead of quietly leaving the differences out.

A desktop application, not a web tool

Recordly is an Electron desktop app distributed as installers for macOS (Apple Silicon and Intel), Windows and Linux from the project’s releases page, with an Arch package maintained separately. Minimum versions are macOS 14.0, Windows 10 build 19041 and any modern Linux distribution. There is no browser version, no account to create before recording and no hosted editor.

Capture backends differ per platform, and so do the limitations

macOS uses native ScreenCaptureKit capture helpers, which is also what its system-audio and microphone paths depend on; Windows uses a native Windows Graphics Capture helper with WASAPI audio; Linux records through Electron’s capture APIs. The practical consequences are stated plainly in the README: Linux cannot hide the real cursor today, so enabling the rendered overlay can show both cursors, and Windows builds older than 19041 fall back to capture that may leave the real cursor visible even though recording otherwise works.

Rendering, projects and updates

Scene composition is handled by PixiJS, and the same scene logic used for the preview renders the exported MP4 or GIF — there is no separate export engine that can disagree with what you approved. A .recordly project file stores the source media path plus editor state, so reopening a project expects the original recording to still be at that path. Updates come through the app, with an opt-in channel for experimental builds, and in-app announcements are fetched from a public file at most once every six hours.

Licence: AGPL-3.0, with a name restriction

The code may be used, modified, distributed and self-hosted, including commercially making videos with it. The reciprocal clause is the part to read before building a product on top: a modified version operated as a website or service must publish its entire source under the same licence. The project also forbids using the Recordly name or branding for a derived project and requires attribution in the user-facing interface and in the repository. Extensions are separate community packages with their own licences.

Sharing exists in the code but is not a hosted service yet

The export menu can render an MP4, upload it to a Recordly Share service and return a viewing page with range streaming, timestamped comments, reactions, captions, password protection, expiry and a private library. The project documentation is explicit that shipped builds point at a locally hosted development endpoint, that the endpoint is deliberately not user-configurable, and that production integration is planned but selected by no build. The service is based on MIT-licensed open-source software with its own licence file and can be self-hosted, and publishing requires a signed-in account.

Captions are generated on the machine

Auto-caption generation downloads a Whisper small model and runs it locally rather than sending audio to a transcription API, which is consistent with the rest of the app’s local-first posture. Captions are editable on a dedicated panel, can be styled and laid out, and can be written out as sidecar files on export. What it will not do is transcribe a language the selected model handles poorly, so a non-English project should check the output before trusting it.

Extensions are permission-gated but community-run

The extension API runs in the editor renderer and can draw into the render pipeline, react to playback and export events, register cursor effects, add settings panels and contribute assets such as frames, wallpapers and cursor styles. Extensions are installed from a local directory or from published bundles. This is a community system rather than a vetted store, so the honest framing is that extensions are code you choose to run, and the documentation lives in the repository.

What it does not do

There is no live streaming, no scene switching or multi-source compositing, no iOS or Android capture, no browser-based recorder, and no team video library with hosted sharing links that work today. Cursor hiding is unavailable on Linux and unreliable on pre-19041 Windows, and system audio on Linux generally requires PipeWire. There is no paid support tier or SLA behind the project — issues go to GitHub and discussion to Discord — and the app is a recording and presentation tool rather than a general video editor, so keyframed motion graphics and audio repair are out of scope.