Who card is for#
Developers building a white-label email template editor
Card's static build and AGPL-3.0 license make it forkable as the foundation for a client-facing template editor. Teams can extend the block catalog, adjust the design system, and serve the editor under their own domain. The commercial license removes AGPL obligations for teams embedding it in a closed-source product.
Skip if:
Requires forking and modifying the source for branding or block catalog changes. If you need a ready-made embeddable SDK with a documented API rather than a forkable app, Card's current architecture requires more engineering work to integrate.
Email designers who need a self-hosted template toolkit
The 78-block library and visual editor cover most transactional and marketing email layouts. Exporting to HTML lets designers hand off tested templates to their email platform without rebuilding them in a proprietary editor, and JSON export preserves the editable structure for future revisions.
Skip if:
If your team relies on a specific ESP's native template system (Mailchimp, Klaviyo, etc.) and needs direct one-click export to that platform, Card's export-and-upload workflow adds a manual step that paid editors with ESP integrations skip.
Infrastructure teams standardizing on self-hosted open source tooling
Card deploys as a static build with zero runtime dependencies behind any web server. Teams already running self-hosted infrastructure can add the email editor without introducing a new managed service subscription or cloud dependency.
Skip if:
Skip if your team needs multi-user template libraries, real-time collaboration, or server-side template storage. Card's localStorage model is single-browser by default; shared team access requires forking and building a storage backend.
The problem it solves#
Paid email template editors tie your workflow to a cloud account. Your templates live in the vendor's database, export options are gated behind paid plans, and if you stop subscribing, access stops too. Platforms like Stripo, Beefree, and Unlayer cover a lot of ground, but each requires a subscription for team features, custom block types, or white-labeling, and none can be deployed on your own infrastructure.
For teams building transactional emails, marketing templates, or white-labeled campaigns for clients, that dependency creates a real constraint. You cannot modify the block catalog without the vendor's developer plan, and when exported HTML does not match your email client's requirements, there is no direct way to alter the export pipeline itself.
How it solves it#
78 preset blocks across 8 categories
The block library covers menu, header, content, feature, call-to-action, e-commerce, transactional, and footer presets. Each block decomposes into rows, cells, and atoms, so a custom layout is built by nesting rather than writing HTML. All 78 presets ship in the public release with no paywall.
Desktop and mobile preview modes
Switch the canvas between 600 px (desktop) and 375 px (mobile) to see how columns reflow. Each row has independent controls: stack columns vertically or hide the row entirely on small screens. The preview renders in a Shadow DOM to isolate editor styles from template styles.
HTML and JSON export
Export the finished template as email-optimized HTML, or save it as JSON to import and continue editing later. JSON import supports two modes: replace the current canvas entirely, or append the imported blocks to the existing template. Imported JSON is validated and sanitized on the way in.
Client-side with no account or server
Card runs entirely in the browser. Templates autosave to localStorage and restore on reload, with no cloud storage or server-side history. Opening the editor requires no login, no account creation, and no network connection beyond the initial page load.
Component tree and in-place editing
Every element is visible in a component tree (Block, Row, Cell, Atom). You can add, move, copy, rename, or delete any node, and the tree and canvas stay in sync. Text atoms support rich formatting: bold, italic, underline, strikethrough, per-atom font size, color, and alignment.
Template-wide design controls
Background color or image, padding, font, and preheader text are set once at the template level rather than per block. This keeps a consistent style across all blocks without overriding individual elements, and changes propagate across the template immediately.
Strengths and trade-offs#
Strengths
- Static deployment with no server dependenciesCard is a Vue app that compiles to a static build. It deploys behind any web server or CDN, with no database, no auth server, and no external API calls at runtime. Teams that already manage static hosting can add the email editor to their stack with a single build output.
- AGPL-3.0 with a commercial license pathUnder AGPL-3.0, you can self-host, use internally, and fork the code as long as changes stay open source. For teams embedding Card in a proprietary SaaS or internal tool without the AGPL obligations, a separate commercial license is available from the author. Unlike Stripo or Beefree, there is no metered pricing based on email volume or team size.
- Portable templates via JSON exportJSON export is designed for re-import: append blocks to an existing template or replace the canvas entirely, with validation on the way in. If you stop using Card, your templates remain usable as structured data rather than locked in a proprietary cloud format.
- Active development with open core modelThe project is undergoing a complete rewrite to adopt modern web standards, as noted in the README. The last push was August 2026, and the open core model means the public AGPL-3.0 release stays current and feature-complete for self-hosters without a separate paid tier.
Trade-offs
- -No arbitrary HTML importCard can import only templates previously exported from Card as JSON. Existing HTML emails from other tools, from ESPs, or hand-crafted cannot be imported and edited on the canvas. Teams migrating a large template library from another editor will need to rebuild those templates from scratch using Card's block catalog.
- -No built-in email sendingCard builds and exports templates only. It has no sending, contact management, or delivery analytics. Plugging templates into an ESP requires copying the exported HTML or JSON into a separate platform, which adds a manual step to any sending workflow.
- -Single-browser localStorage storageTemplates persist in browser localStorage with no server-side storage, no multi-device sync, and no shared team library. A developer forking the project can build persistent storage into a custom deployment, but out of the box the model does not scale to teams sharing templates across browsers.
card vs alternatives#
Card vs Stripo
Stripo and Card both provide drag-and-drop HTML email editors, but they serve different deployment models. Stripo is a managed cloud service with no self-hosting path; Card is AGPL-3.0 open source and deploys as a static build on your own infrastructure.
| Feature | Card | Stripo |
|---|---|---|
| License | AGPL-3.0 | Proprietary |
| Self-hosting | Yes (static build) | No |
| Account required | No | Yes |
| Template storage | Browser localStorage | Vendor cloud |
| ESP integrations | No (HTML/JSON export) | Yes |
Card is the better choice when you need self-hosted deployment for data privacy, want to fork and extend the block catalog, or need AGPL-licensed tooling you can build on. Stripo is the stronger fit when you need direct ESP integrations, a larger managed block library, or a shared cloud template library your team can access from any browser without infrastructure setup.
Card vs Beefree
Beefree is a cloud-based email editor with no self-hosting option. Like Stripo, it requires an account and stores templates server-side. Card's key difference is static deployment with no account and no proprietary template storage.
| Feature | Card | Beefree |
|---|---|---|
| License | AGPL-3.0 | Proprietary |
| Self-hosting | Yes | No |
| Account required | No | Yes |
| Template storage | Browser localStorage | Vendor cloud |
| Export formats | HTML, JSON | HTML, various |
For teams that prioritize self-hosting and data ownership, Card is the more appropriate choice. Beefree is the better fit when your team needs an out-of-the-box managed editor with no infrastructure commitment and direct integration with major ESPs.
Quick start#
Install dependencies with pnpm and start the dev server after cloning the repository.
```bash
git clone https://github.com/mysigmail/card
cd card
pnpm install
pnpm dev
```What it's built on#
- Languages
- JavaScriptTypeScript
- Frameworks
- Vue
FAQ#
Can I import an existing HTML email into Card?
No. Card can only import templates that were previously exported from Card as JSON. Arbitrary HTML from other tools or ESPs cannot be imported and edited on the canvas. If you have existing templates from another editor, you will need to rebuild them using Card's block catalog.
Is Card licensed for commercial use?
Under AGPL-3.0, yes. You can self-host Card and use it for commercial purposes, including internal team use, without paying a license fee. The AGPL requirement kicks in when you distribute a modified version over a network as a SaaS: those source changes must be released under the same license. For embedding Card in a proprietary closed-source product without opening your source code, the author offers a separate commercial license.
Does Card send emails?
No. Card builds and exports email templates only. Sending, list management, and delivery analytics are handled by your email platform. Take the HTML export from Card and upload it to your ESP of choice.
Where are my templates stored?
Templates autosave to your browser's localStorage. There is no cloud storage, server-side history, or account required. Export as JSON to save a portable copy outside the browser. If you clear browser storage or switch to a different browser, the localStorage version will be lost unless you have an exported JSON backup.
What does open core mean for Card, and can I fork it?
The public GitHub release under AGPL-3.0 is the open core of MySigMail Card. You can fork it, extend the block catalog, and share your changes under the same license. Using the published build for commercial team email templates is permitted. The commercial license applies only if you embed Card in a proprietary product you distribute to users over a network without releasing your source code.
Similar open-source tools#
FckSignups
Open-source tools that work instantly, no signup required
fmt
Fast, type-safe C++ formatting that replaces printf and iostreams
dograh
Open source voice agent builder with telephony and BYOK AI support
VvvebJs
Open source drag-and-drop page builder for Bootstrap 5 sites
openpanel
Open-source analytics with funnels, replay, and self-hosting
LinkBreeze
Self-hosted Linktree alternative with one-command Docker deploy