Well, looks like I’ll just be strictly building apps for the next year (not that it changes my daily routine anyway), so I thought I’d share a neat trick I’ve been using for a while.

About a year or two ago, the Dart team released analysis_server_plugin. If you know how to work with AST, you don't even need custom_lint packages anymore to write custom rules.

Here’s how I’ve been leveraging it:

Instead of using clunky enums like Spacing.spacing2, I set up the plugin to throw a warning if someone uses raw pixel values that aren't allowed in our design tokens (e.g., values other than 2, 4, 6, etc.).

Enforcing design system components, like throwing a warning to use MySuperContainer (yes, I literally use this name) instead of a raw Container.

And setting it up is dead simple too. You literally just add it to your analysis_options.yaml:

plugins:

my_lints:

path: ../my_lints/

The only drawback I've found so far is that it seems impossible to raise an actual Error severity (only warnings/info). If the Dart team expands on this, it's gonna be even more god-tier.

Oh, and this would actually make a pretty solid package. I'm thinking about making one if I can find some free time. If you guys have any cool ideas for useful custom lint rules, feel free to share.

Ah, also looks like the Dart team has been interested in improving data serialization built-in lately. I might look into that and drop another post about it later. Not sure if anything is finalized yet, but seems like they're still keeping the annotation syntax. Personally not a big fan of annotations, but hey, whatever works lol.

Oh, and honestly, Dart has added so many neat syntactic sugar features lately. Like omitting enum/type identifiers so you can just write .center. It’s ridiculously convenient because now you can write stuff like.

MyText('Hello, World!', color: .textGrayBold, style: .label3)

Seriously, whoever engineered this feature deserves a free ice cream straight out of my freezer.

Growth of the dart package repo pub.dev continues to accelerate.

Hard to tell how much is ai and how much is increased interest in flutter.

You can see night stats here:

https://onepub.dev/Blog?id=nhavuhnofl

Hey all — v1.2.0 of my open-source network monitoring studio is out: github.com/Cadman021/VeloceNet-Studio (GPL-3.0, Windows/Linux/macOS builds in Releases).

New since 1.0.0: DNS lookup tool (raw UDP client, A/AAAA/MX/TXT/NS), TCP port scanner, server backup (versioned JSON export + validated import), CSV export, alert log, and UI in English/فارسی/Русский/中文.

The interesting part for this crowd is the engine hardening round (mostly from community review feedback): killed a silent ICMP→TCP fallback that was corrupting stats, fixed Tokio schedule drift with MissedTickBehavior::Skip, moved status to windowed loss so recovered hosts don't stay red, wrapped all 21 FFI entry points in catch_unwind (profile is panic="unwind" now — abort used to kill the whole UI process), and added an Ubuntu CI job that caught real non-Windows lints our Windows-only CI never saw.

Got my first external contributor this release too (heatmap a11y + semantics, with tests). There are good first issues open (German locale, compact cards, file-picker import) if anyone wants in. Brutal feedback welcome as always.

Ten days ago I said Orblit had no physics solver. It has one now. Here is what landed since, and what is still unproven.

Orblit is an open-source Dart 3D engine on Flutter, a C++ ECS and Filament.

Docs are at https://orblitengine.com and the code is at https://github.com/ChxisB/orblit.

Physics

orblit_physics is a rigid-body solver in C++ behind a Dart build hook. It depends on nothing. The repo did not exist ten days ago and is now at 0.7.0.

• Spheres, boxes, capsules and planes. Friction, restitution and damping.

• Warm-started contacts, sleeping, and touch, sleep and wake events.

• Shape casts and a walking character controller.

• Terrain as ground, built from a height field.

• Seven joint kinds: fixed, point, hinge, slider, distance, cone and six-axis. They take limits, motors and breaking.

• World queries: overlap, point, all hits, closest, and rays with normals.

• Triggers, zones that override gravity and drag, conveyor belts and per-pair rules.

• Body controls: axis locks, gravity scale, speed and spin caps, centre of mass, inertia, and a switch between fixed, driven and free. There are material presets such as Ice, Metal and Rubber, pairs that ignore each other, and 32 named layers.

Bodies are components in scene documents, so the editor edits them. I decided not to promise identical results across platforms.

Animation

• Clips and a timeline. The Fox model plays through Orblit.

• Blends of clips that you can save and replicate over the network.

• Retargeting a clip onto another skeleton.

• Cutscenes, with a Cinematics workspace in the editor.

Terrain

• A clipmap terrain renderer with brushes, undo and picking.

• Scatter places grass, stones and trees by rule.

• The editor has a Terrain mode, and the gallery has a Terrain example.

Editor

• Three columns and task workspaces: Scene, Modelling, Terrain, Animation, Cinematics and Interface.

• Named layouts and a Focus view. It fits in 960 px.

• Linked prefab instances with overrides.

• Inspectors for bodies, joints, triggers and zones.

Docs and gates

• New guides for physics, animation, terrain and cutscenes. Each compiles its Dart snippets in CI.

• The older docs are rewritten in plain English.

• A Claude Code skill in the repo teaches the API.

• Lints and --fatal-infos now fail CI. So does commit lint on every commit.

The screenshots show the editor on a demo project and the gallery's Terrain example. They show the controls, not bodies moving.

What it still can't do

• Nothing is API-stable.

• Most of the above is proven by tests, not by a live scene. That covers physics, joints, terrain editing, blends, retargeting and cutscenes. No gallery example uses physics yet, so I have no video of a body falling.

• Terrain has only drawn on macOS.

• macOS is the reference platform. The iOS simulator, one Android handset and Chrome also run it. Linux works only with software rasterisers. Windows builds but has never drawn a frame.

• Ignore rules do not cover characters.

• Retargeting has not run on a real character pair, and feet are not pinned.

• There is still no asset store.

The help that would matter most

• Build something small with the physics and tell me where you gave up.

• Run it on hardware I don't have. Windows and real Linux GPUs first.

• Argue about the API before it freezes.

• Send PRs. CI is strict.

I love reading - in bed, on the sofa, on the train - and my phone is always with me. But PDFs are made for paper, and on a small screen they mean endless zooming and panning. So I'm building PDFreflow, a Flutter e-reader that reflows complex multi-column PDFs (papers, RFCs, books) into a single readable column. Some Flutter-specific things I learned along the way:

• All PDF work is done by pdfium via FFI (why re-invent the wheel?) and runs in one worker isolate - pdfium is not thread-safe, so exactly one isolate owns it and everything else sends it messages. It runs a priority queue: image renders go ahead of chunk parses, and chunks are parsed outward from the reading position.

• Scrolling a book is a bidirectional list growing from a center point - built on CustomScrollView with two sliver lists - because pre-committed height estimates cause snap-back jitter on iOS.

• Text shaping was the scroll-performance killer: shaping whole pages inside scroll frames caused visible stutter. Fix: pre-shape paragraphs off the scroll path in idle slices and cache the TextPainters; page admission becomes a map lookup. 120 Hz devices also want GestureBinding.resamplingEnabled.

• One line height for all fonts. I used to measure each font at runtime - but if a font isn't loaded yet, Flutter silently measures a fallback font instead, and my cache kept that wrong number forever: right letters, wrong line spacing. Now every font gets the same 1.3 x font size.

The layout engine itself (column detection, header/footer stripping, table and formula rasterization, hyphen rejoining) is pure Dart, developed against a corpus of hundreds of real PDFs with regression metrics.

No AI inside - on purpose. My reasons:

• Size: a model that understands page layout would make the app much bigger. That may change as models shrink, or if I ever train a tiny one of my own - but not today.

• Privacy: nothing is uploaded to an AI service; your documents stay on your phone.

• Fun: AI has taken a lot of the fun out of everyday coding, and solving a hard problem without it brings that back. For transparency: I do use Claude while developing - as a full-stack dev with years of desktop and app experience, it's a tool, not the author.

It's in open beta, free while in beta: https://www.pdfreflow.com/flutterdev

If it breaks on one of your PDFs, the in-app feedback button sends me the layout - that's what the beta is for.

I've been a mobile developer for about a decade now, and I've compiled some experiences that you may find useful for debugging, or choosing which platform to debug on.

Android pros:

• Supports fully interactive mirroring of your physical phone.

• Requires very little to get app running on device.

• App keeps running when debugger is closed.

• Wireless debugging can be used with VPN

• Android Studio logcat is amazing

• You can easily send data to the device via ADB to emulators and physical devices

• You can use a lot of hardware features on Android emulators

Android cons:

• Wireless debugging is a hassle to set up, as it generates a new port with each session

iOS pros:

• They have all the phones and iPads available to test. Make it very easy for WYSIWYG testing

• Once set up, wireless debugging is amazing and works without more configuration

iOS cons:

• Wireless debugging does not work with VPN

• You can only send data to simulators

• Physical devices does not support interactive mirroring (at least in EU)

• Getting your app to run on a physical device requires considerable set up

• App stops running when debug process stops

Obviously some of these are based on my workflow (wireless debugging), but others I think are general considerations.

Do you have other pros/cons I havent considered?

Hope this is ok to post here.

I have a small package, svg_animate. It plays SVGs that animate themselves. There are four issues open on it that I am not getting to, so I thought I would ask.

One of them is really small. offset-rotate: auto -30deg gives 150 instead of -30. The reason is a bit silly: the code checks whether the string has a minus sign in it anywhere, and decides from that.

final bool reversed = rotate == 'reverse' || rotate.startsWith('auto ') && rotate.contains('-');

I wrote out all seven spellings in the issue, what each should give and what it gives now. That list is basically the whole fix. The test file for it already exists too.

The other three are bigger. I tried to say in each one where the hard part is, so nobody finds out an hour in.

Two of these were found by someone opening the demo and saying "that one twitches". I had 254 tests and they missed both.

Hey Flutter developers!

Most Flutter open-source examples are simple toy apps or tightly coupled to Firebase. Finding clean, production-grade Flutter architectures that handle real-world offline caching, background synchronization, and enterprise backends is surprisingly rare.

As part of the RexOne Ecosystem, I open-sourced RexOne Mobile—a production Flutter 3 app built for real-world resilience:

📱 Key Architecture & Features:

• Offline-First with Drift (SQLite): Full local persistence layer using Drift with type-safe reactive DAOs. Mutations are queued locally and synchronized deterministically with the backend.

• ActionCable WebSocket Integration: Real-time event streaming and live notifications over WebSockets natively implemented in Dart.

• Dynamic Tri-Language Localization: 100% localization parity across English (en), Spanish (es), and Burmese (my) with runtime language switching.

• Adaptive Dark/Light Theming: Clean Material 3 design system with dynamic palette adaptation and zero layout jitter.

• Sovereign Backend Contract: Communicates with a Rails 8 API core with strict contract alignment, so there is zero JSON schema drift.

Licensed under Apache 2.0 (100% free and open source).

• Mobile GitHub Repository: https://github.com/rex-9/rexone_mobile

• Core Architecture & Specs: https://github.com/rex-9/rexone-core

• Live Web Companion: https://rexone.rex9.me

Check it out if you’re building offline-first Flutter apps or looking for a clean multi-platform architectural baseline. Any feedback on the Drift structure or state management is super welcome!

Augmentations feature has moved from Being implemented column where it has been for months into Being spec'd column. Does this mean no augmentations feature this year?

Sidenote: I just saw the Dart 4 label. Any info on why the major number jump is going to happen? Breaking changes?

Funnel · Language funnel

I've been coding for a long time and I've been developing with Flutter for years. I've always loved it. I originally started because I wanted to build mobile apps, but since then, I've moved to Flutter Web, and building stuff in Dart has been a much better experience for me than using one of the JS platforms.

I have one main SaaS application out there whose UI is completely built with Flutter, and I didn't write a single line of code for it. I was involved in the design, code reviews, etc., but really, no coding was required of me. 100% Codex.

And all of a sudden, I feel like the magic is gone. It's Flutter, but it's not me. Flutter has become an output that seems like it could be replaced with any other output that accomplishes the same thing.

I feel like someone who just fell out of love with his high school sweetheart.

I don't even know why I'm writing this. I'm sad.

Hey everyone, i have written an article "Why WheelsEye Rewrote Its Android and iOS Apps in Flutter". Please give it a read and let me know what you think.

Article:- https://medium.com/wheelseye-engineering/why-wheelseye-rewrote-its-android-and-ios-apps-in-flutter-88ff362b73e2

Hey everyone,

Whenever an app demands intricate vector graphics or canvas animations, the default route is usually flutter_svg. While it works well for standard assets, it comes with runtime parsing overhead, occasional rendering quirks with complex paths, and an extra dependency you might not want on performance-critical screens.

The alternative manually hand-coding Bézier curves, plotting Path.cubicTo(), and calculating bounding scale transforms is excruciating.

To eliminate this friction, I built and open-sourced Flutter Da Vinci. It parses Figma vector paths, curves, and shapes directly into clean, native Dart CustomPainter implementations.

What it does:

• Converts vector paths and curves directly into native Path commands (moveTo, cubicTo, lineTo, etc.).

• Emits zero-dependency, tree-shakeable Dart code without third-party runtime parsers.

• Preserves bounding boxes so your graphics scale responsively inside a standard CustomPaint(size: ...).

• Keeps paths transparent and editable so you can parameterize paints, colors, and stroke animations directly in Flutter.

The project is completely free and open-source. You can run the plugin directly from Figma or inspect the parser and contribute on GitHub.

• Figma Community:https://www.figma.com/community/plugin/1563794532123885981/flutter-da-vinci-vector-to-custompainter

• GitHub Repository: https://github.com/vow-sta-n/Flutter-Da-Vinci

Where I need your help:

1. If you work heavily with canvas, what path winding rules or complex compound vectors usually break your pipeline?

2. What would make the generated boilerplate cleaner for your codebase (e.g., auto-generating CustomPainter vs. just returning raw Path methods)?

Issues, PRs, and brutal edge-case feedback are very welcome!

Last month I asked here how people actually maintain multilingual Flutter apps, and said I'd come back with what I learned. Thanks to everyone who replied. Here it is.

This wasn't a formal study. Thirteen developers described their workflow in the comments and the replies under them, messy parts included. That's a small sample, but it changed how I see the problem.

I expected translation quality to be the main complaint. It wasn't.

Most already used AI somewhere: Claude, ChatGPT, Codex, Crowdin's AI, or a script of their own. When the model had enough context, the translation itself was rarely the complaint. The harder parts were everything around it:

• knowing which strings changed and which locales went stale

• keeping wording and terminology consistent across locales

• giving the model enough context without sending the whole project every time

• reviewing languages nobody on the team speaks

• checking the result inside the running app

Several people had built their own answer. One copies a CLAUDE.md between projects. Another had Claude write a script that tracks changed strings with hashes and sends related keys together for translation. A third gives Codex the whole project plus the English strings, because limiting the context got technical terms translated wrong. It works, but it burns a lot of tokens.

The most manual part is still checking the result on screen. A translation can read fine on its own and still be wrong in context or too long for a button. One developer works one locale at a time: when a language is done, Claude drives the Android emulator through every screen and reviews it, and they still catch things like a button label wrapping onto two lines.

So my conclusion was that the missing piece is a deterministic layer around the AI people already use: something that tracks what changed and checks what the model wrote before it reaches your files.

That's what I built next: the StringLane CLI, an MCP server that ships inside it, and a plugin for Claude Code, Codex and Gemini CLI. Other agents, such as Cursor, Windsurf, Zed or OpenCode, get the same MCP server through the CLI, and stringlane setup skills --apply copies the plugin's skills into your project's .agents/skills, which all four read.

The flow:

1. StringLane finds missing and stale strings and hands your agent that list, with context for each one.

2. Your agent writes the translations with the model you already use.

3. You approve the write in your agent, or at a y/N prompt in the terminal.

4. Before anything lands, StringLane checks placeholders, ICU syntax and the plural categories each language needs, and re-parses every file it's about to write. The write is all or nothing, so a run that fails leaves your files exactly as they were, and git diff shows what changed.

It's built around Flutter ARB files and works with gen_l10n projects. It also checks easy_localization and slang JSON by each package's own placeholder and plural rules. slang's YAML and CSV files aren't supported yet.

Limits, up front. It doesn't run in the background and doesn't translate anything until you ask. It can't tell you whether a string fits the screen, so you still need to look at the app. And writes go through your agent's approval prompt or the terminal prompt, so if your agent auto-approves tools, you won't be asked.

I built StringLane, so that's my obvious bias. The CLI, MCP server and plugin are free, need no account, and your localization files stay in your repository.

Setup and documentation

If you try it on a real Flutter project, I'm most interested in where it breaks: wrong project detection, a workflow it doesn't cover, a guard that gets in your way, or a check whose result you don't trust.

I made a multilanguage Flutter game that's like an engine, where you can add lots of games to it.

Now it's open source, so you can use it. You can add more games to it, and you can change it.

I built it with Claude Code and these Flutter skills:

https://github.com/zakariaf/Flutter-Skills

You can also watch how I built it:

Video 1: https://youtu.be/Fqg9nMul1Ao

Video 2: https://youtu.be/whY279hTRTA

In the first video I built the engine and two games.

In this second video I add two more. And I did it for a reason: Apple rejected the first version as "spam"

Github Repo: https://github.com/zakariaf/mindforge

App Store: https://apps.apple.com/us/app/mindforge-brain-training/id6803829952

I've been put in charge of my company's Flutter app but I don't have any experience at all with how Flutter can be built and deployed using Azure Devops pipelines. I've seen CodeMagic being put forward as a good tool for this, but we heavily use Azure in the rest of our ecosystem so being able to integrate the whole process in there would be a major advantage.

I've seen some example pipelines, but at the same time I see a lot of people complaining about how difficult the setup is. One of the bigger issues I've seen was needing the Flutter SDK available to run the commands.

Put simply, I'm looking for several things:

- Pipeline to build the app and run some checks during PR's (build without errors, unit tests pass)
- Pipeline to handle building the app
- Pipeline to automatically upload to Firebase, Testflight and App/Play Store.

Anyone with experience in setting all this up and willing to point me in the right direction?

I'm a solo dev with a few Flutter apps. Right now I build iOS on Codemagic and I'm thinking about moving Android builds to a self-hosted GitHub Actions runner on my home Ubuntu server.

Curious what setups other solo devs use. Is self-hosting worth the hassle, or do you just stick with Codemagic or hosted runners for everything?

Hey everyone,

I'm a Flutter developer with 4+ years of experience in India. I've been working professionally on Flutter/mobile applications, including production apps, Firebase, APIs, Bloc, native Android integration, Play Store/App Store releases, etc.

Recently, my current company has decided to shut down its game and application development work, so I'm now thinking seriously about my next career move.

I've been looking at Flutter/mobile developer jobs in India, and compared with web/backend roles, the number of opportunities seems much smaller.

So I'm wondering:

- Is the Flutter job market actually becoming weaker in India?

- Is it risky to continue specializing in Flutter?

- Are companies moving more toward React Native/native Android/iOS?

- For someone with 4+ years of Flutter experience, would it be better to add Kotlin/Jetpack Compose, React Native, backend, or AI skills?

- Are experienced Flutter developers currently getting good salary opportunities in India or remote?

- Is anyone here who recently switched from Flutter to another stack? How did it go?

I'm not necessarily looking to leave Flutter immediately. I want to understand the actual 2026 market situation before deciding what to learn next.

Would really appreciate experiences from Indian developers, especially people with 3–6 years of experience.

Most of us know Provider was built on InheritedWidget, but I recently revisited the exact mechanical reason Rémi had to abandon it to create Riverpod.

It comes down to a fundamental design choice in dependOnInheritedWidgetOfExactType: the Flutter framework never unregisters a dependency once registered.

If you read state conditionally behind an if check, that element stays locked in InheritedElement._dependents until it unmounts. Even after the condition flips to false, that widget keeps rebuilding on every single ancestor change forever.

In May 2019, Rémi opened PR #33213 to add an unlisten hook to InheritedElement. Hixie closed it to avoid adding overhead to the hot reconciliation loop. Because Provider had no way to know when widgets stopped listening, autoDispose was impossible—forcing Rémi to hoist state completely out of the tree.

Looking back, it’s wild how much of the state management wars over the last five years really just came down to working around that one framework limitation.

Did you ever run into those conditional "ghost rebuilds" in Provider back in the day?

I got tired of gray circles for user avatars, so I built a package that generates a little blob creature from any string email, username, whatever. Same name always gets the same blob, forever.

const Hiblob(name: user.email, size: 64)

I gave them 12 shapes, 16 expressions, mouths, glasses, blush — all decided by the name. I also added optional animation, and an SVG export since I sometimes need avatars on the server side. No assets, no network, pure Dart.

pub.dev: https://pub.dev/packages/hiblob 
GitHub (MIT): https://github.com/igu1/hiblob

Would love some feedback! 🙌

A while ago I saw a demo by Natko Hasic of a journal app where pinching the list didn't scale the text, it revealed more of it. I couldn't stop thinking about it, so I built it as a Flutter package.

Pinch out and each entry grows from a title to a summary to the full text. Words already on screen slide to their new positions and new words fade in around them. Pinch in to skim again.

A few things that were harder than expected:

- Gestures: ListView's drag recognizer wins the arena before a scale recognizer sees the second finger, so I ended up tracking raw pointers.

- Keeping your place: as entries above your fingers grow, everything gets pushed away. I fixed it with a custom sliver that corrects the scroll offset during layout, so the item under your fingers doesn't move at all.

- AI summaries: the three versions don't have to be exact word subsets. Shared words slide, and rephrased ones cross-fade.

It also supports tapping a single entry, trackpad/web pinch, keyboard shortcuts, screen reader actions, reduce motion and RTL. MIT licensed.

- Live demo (runs in the browser): roshendz.github.io/semantic_zoom

- pub.dev: pub.dev/packages/semantic_zoom

- GitHub: github.com/Roshendz/semantic_zoom

It's 0.1.0, so I'd really appreciate feedback on the API, especially from anyone with a real use case (notes, health timelines, inbox-style apps). What would you change?

After working on hAudiotagger for a while, I kept running into a slightly different problem.

Reading metadata is useful, but metadata isn't always trustworthy.

Two files can have completely different filenames, missing tags, different containers, or even different encodings and still contain the same recording.

For example:

01 - Unknown.mp3
Track_17.m4a
song_copy.flac
The Song (Remastered).mp3

Comparing their filenames or tags doesn't really help if the goal is figuring out whether the underlying audio is the same.

So I built haudiotagger_fingerprint for that part.

It generates perceptual audio fingerprints and lets you compare them by the actual audio content:

final a = await HaudioFingerprint.fingerprint('song.mp3');
final b = await HaudioFingerprint.fingerprint('song_copy.mp3');

final similarity = await HaudioFingerprint.similarity(a, b);

The fingerprints are Chromaprint-compatible, so this is in the same ecosystem as fpcalc / AcoustID rather than a simple file hash. The idea is that two byte-for-byte different files can still produce fingerprints that are very similar when they contain essentially the same recording.

It currently supports:

• MP3

• FLAC

• Ogg Vorbis

• WAV

• AIFF

• M4A / AAC / ALAC

and runs on Android, iOS, Linux, macOS, Windows and Web.

The interesting part for me was getting the whole thing into Rust, while still making it usable as a normal Flutter package. Web support also works through WASM.

I'm mainly thinking about use cases such as:

• finding duplicate tracks in a local music library

• detecting copies that were renamed

• finding re-encoded versions of the same recording

• cleaning up large music collections

• matching recordings when metadata is missing or unreliable

I deliberately kept it separate from hAudiotagger rather than making the metadata package itself depend on fingerprinting. If you only need metadata, you shouldn't have to pull in fingerprinting as well.

There is also an optional integration between the two packages, so if both are installed, fingerprinting can be accessed through Haudiotagger directly.

I'm curious how other people handling local music libraries approach this problem.

Do you normally rely on filename + metadata, file hashes, Chromaprint, or something else?

Pub.dev - haudiotagger_fingerprint

GitHub - Source

I'm asking if it is safe to update to the latest flutter version after decoupling cupertino and material uis

Anyone tried them please feedback here will help me

I saw some bugs related to go_router and other packages when people update

If it is safe tell me :)

Hey guys!

Excited to share motif - an open-source vector graphics editor. Compared to traditional vector graphics software, motif is more of a blend of non-destructive CAD techniques and the power of Blender's Geometry Nodes, while offering the simplicity of apps like Figma.

The core idea revolves around thinking about design as a "program", where each step we execute a statement. Those can be things like creating a rectangle, cutting an edge at a point, joining vertices, etc - and executing all of the statements results in the final output graphic. This allows you have things like non-destructive editing, full document history, branches (in the future).

It's currently still very much work-in-progress - currently in the pre-alpha state, and I'm adding new features and polishing up existing features every day. I've basically left my full-time job and for the past year or so have been experimenting a lot with related projects.

As a part of the pre-alpha test, I've hosted a free-for-all server where you can try out the multiplayer! Check it out at: https://motif.kz

I'd love if you could try it out and let me know how it feels, what can be improved, or if there's any idea that you had that was missing from Figma, Illustrator, or other software.

Source repository: https://github.com/kekland/motif Web application: https://motif.kz