Your anime universe / One app
Turn an endless collection into an anime universe you can actually command. Nimlat brings nearly twenty thousand titles, watch progress, new releases, and download search into one desktop app: fast, local-first, and impossible to mistake for anything else.
- Catalog
- Nearly 20,000 titles
- Watch list
- AniList · MAL · Simkl
- Releases
- Never miss one
- Local-first
- The speed of your own PC
Everything under control
Do more than track anime. Command your entire library.
From discovery to the next episode, Nimlat keeps everything in its place: connected series, synchronized progress, upcoming seasons, and ready-to-launch download searches. The catalog lives on your computer, so filters, details, and personal status answer instantly. No more bouncing between websites, lists, and forgotten tabs.
Demo
See it in action. Picture your library here.
From the first glance to the next episode, see how Nimlat turns thousands of titles into a personal library that is clear, immediate, and ready to use.
The command center
This isn't a watch list. It's your anime universe.
Explore the entire catalog as a media wall, step inside every series, watch upcoming releases, and launch the right search when it is time to watch. Every screen is designed to get you to what you want faster.
Screenshot 01 / library
Library Explorer
The main media wall: search, filters and library state designed for large catalogs.
Screenshot 02 / details
Media Detail Hub
A complete series view with episodes, cast, staff, relations and actions in one context.
Screenshot 03 / releases
Release Watch
The console for future episodes, new seasons and releases not yet integrated.
Your history comes with you
Bring every watched episode with you.
Every tracker has a different authorization flow. Open Integrate watch lists, choose a provider, and follow its dedicated guide; this section also covers the searches you prefer to use.
Preferences / WatchedIntegrate watch lists
Each service uses a different connection flow. Open the provider you want to integrate and follow only its dedicated instructions.
Provider / Browser sign-inMyAnimeList
Connect Nimlat to your MyAnimeList account without sharing your password.
In MyAnimeList — create the Client ID
- Open MyAnimeList API clients. Sign in if MAL asks you to, then choose Create ID.
Complete the form with these values:
Values for the MyAnimeList form App Name NimlatApp Type otherNimlat is a desktop app and uses PKCE without a Client Secret.Client ID Generated by MAL after submissionThis is the value to copy into Nimlat. Client Secret Not issued for App Type otherWith App Type other, MAL does not issue it and Nimlat does not request it. App Description Personal desktop app for managing and syncing an anime watch listApp Redirect URL http://127.0.0.1:8765/callbackHomepage URL https://www.nicolo-zanetti.com/projects/nimlatApp Logo URL Leave blank Privacy Policy URL Leave blank Terms of Use URL Leave blank Commercial / Non-Commercial non-commercialName / Company Name Your name or MAL username Purpose of Use hobbyistAPI License and Developer Agreement Select the agreement checkbox - Submit the form.
- Re-open the client you just created. MAL should now display its Client ID; copy it.
In Nimlat — start the connection
- Now open Nimlat: Preferences > Watched > MyAnimeList panel.
- Paste the value copied from MAL into Client ID.
- Click “Connect MyAnimeList”.
- Enjoy.
Provider / AniList tokenAniList
Connect Nimlat to your AniList account without sharing your password or Client Secret.
In AniList — create the application
- Open the AniList developer settings, sign in and choose Create New Application.
Complete the form with these values:
Values for the AniList application Name NimlatRedirect URL https://anilist.co/api/v2/oauth/pinIt must match exactly, with no extra spaces.Client ID Generated by AniList after you saveYou will use this value in Nimlat and in the URL in the next step. Client Secret Do not paste it into NimlatNimlat uses the Implicit Flow and does not need this value. - Save the application.
- AniList will display the Client ID; copy it.
In Nimlat — request the token
- The connection uses AniList’s documented Auth Pin flow, so you can copy the token directly from an AniList page.
- Open Preferences > Watched > AniList.
- Paste the Client ID into AniList client ID.
- Click Request access token from AniList. Nimlat will open the correct address in your browser.
- Sign in to AniList if asked and authorize Nimlat.
- AniList will display an access token; copy the complete token.
In Nimlat — save the connection
- Paste the token shown by AniList into Access token or redirect URL.
- Click Save token. Nimlat verifies the connection before storing it.
- Enjoy
Provider / Browser sign-inSimkl
Connect Nimlat to your Simkl account without sharing your password or Client Secret.
In Simkl — create the application
- Open Create an app in Simkl and sign in if asked.
Complete the form with these values:
Values for the Simkl application Name NimlatDescription Personal desktop app for managing and syncing an anime watch listRedirect URI http://127.0.0.1:8765/callbackIt must match exactly, with no extra spaces.Client ID Generated by Simkl after you saveThis is the value to copy into Nimlat. - Save the application.
- Simkl will display the Client ID; copy it.
In Nimlat — start the connection
- Open Preferences > Watched > Simkl.
- Paste the value copied from Simkl into Client ID.
- Click Connect Simkl.
- Sign in to Simkl if asked and authorize Nimlat. The connection will complete automatically.
- Enjoy
Preferences / DownloadConfigure download search sites
Nimlat does not download files or bypass sites: it builds a query and opens the search page in your chosen browser.
Configure the provider
- Open Preferences > Download and choose Add new provider.
- Give it a readable name. Choose Torrent for direct torrent listings or Index for broader search sites.
- Paste the complete search URL and put {query} where the site expects search text, for example https://example.com/search?q={query}.
- Save and leave the provider enabled. You can disable, edit or remove it at any time.
- Under Default browser, use the system browser or select a specific executable with Browse and save the changes.
Use only sites and content for which you have the necessary rights. When {query} is omitted, Nimlat appends the encoded query to the URL.
Invisible power
It looks like a machine. It responds like one.
Behind the neon interface is a desktop engine built for enormous catalogs: persistent updates, local caching, background processes, and secure boundaries. You get an immediate library; Nimlat handles the complexity.
Desktop architecture
The power stays behind the scenes.
A responsive interface in front; specialized services and three local databases behind it. Every layer does one job and does it well, keeping Nimlat fast, stable, and ready to grow with your library.
- 01 / UIReact 19 renderer
- 02 / BOUNDARYTyped preload bridge
- 03 / DOMAINMain-process services and daemons
- 04 / STATE3 local SQLite databases
Feature map
Implemented capabilities
Product Experience
The application surface: library, tracking, media details, future releases and operational tools.
Local-first anime library manager
Desktop app for organizing, monitoring and completing a personal anime library, with data stored locally in SQLite.
Library Explorer
Main view for exploring groups, series and standalone media with search, filters, integration states and ignored content.
Media Detail Hub
Dedicated pages for each media item with catalog details, episodes, characters, staff and download tools.
Release Watch
Dashboard for monitoring future releases, upcoming episodes, new seasons and already released content not yet integrated.
External Tracking Sync
Two-way import and synchronization of watch state with AniList, MyAnimeList and Simkl.
Download Search Builder
Configurable tool for generating download search queries with presets for quality, source, subtitles, audio and release group.
Data Pipeline
The data engine: ingestion, incremental updates, persistent queues and catalog normalization.
AniList + Jikan Data Ingestion
Pipeline for importing metadata, relations, episodes, characters, staff and images from external sources.
AnimeDB Baseline System
Preloaded catalog database that can be downloaded at startup and updated over time without rebuilding everything from scratch.
Incremental Catalog Updates
Idempotent incremental updates with persistent cursors, safety overlap and protection against unnecessary retries.
Hydration Queues
Persistent queues for enriching data in the background, with retry, failure state and a dedicated error page.
Release Date Resolution
Normalization of release dates from next airing episode, start date and fallback providers.
Deterministic Grouping Engine
Automatic series grouping based on the AniList relation graph, with support for user overrides.
Desktop Architecture
The local Electron structure, with explicit boundaries between UI, preload, main process and databases.
Electron Secure Boundary
Separation between renderer, preload bridge and main process, without direct renderer access to Electron or SQLite.
SQLite as Source of Truth
Three separate local databases for anime catalog, user state and image cache.
Typed Context Bridge Contracts
Shared TypeScript contracts define every API exposed by the preload, making the cross-process boundary compiler-verifiable.
Thin IPC Layer
Thin IPC handlers, with business logic moved into services and dedicated database operations.
Facade-Based Domain Access
Data access through facade and service layers, avoiding scattered SQL across the rest of the app.
Main-Process Domain Services
Selection, synchronization and mutation rules live in dedicated main-process services rather than React components.
Event-Driven Updates
Internal buses for propagating changes to groups, media, episodes, release watch, tracking and hydration progress.
Local Image Cache
Local image cache for fast loading, offline reuse and controlled fallbacks.
Atomic Baseline Replacement
The downloaded catalog is checksum-verified and replaced with backup and rollback protection for the active database.
Encrypted Credential Storage
Provider tokens and credentials go through Electron safeStorage: Windows Data Protection API on Windows and Keychain on macOS.
Background Service Lifecycle
Coordinated daemons run scanning, hydration, catalog updates, caching and release tracking outside the render cycle.
Native Packaging and Updates
Electron Builder produces native packages while the main process owns update checks instead of leaking them into the renderer.
Visual / Interaction Design
The most distinctive layer: technical, animated, deliberately excessive UI built as a showcase.
Distinctive Cyber-Neon UI
Strong, technical and deliberately non-minimal visual identity, designed as a UI engineering showcase.
Pixi-Powered Animated Backgrounds
Atmospheric animated backgrounds built with Pixi and integrated into the app experience.
Custom Interaction Components
Custom visual controls such as neon console, flip switch, circuit toggle, glow buttons and status controls.
Media Wall Rendering
Performant rendering of visual grids with texture cache and optimized image handling.
Ant Design Theming Layer
Use of Ant Design with a custom theme and coherent overrides to keep components robust but visually recognizable.
Engineering Quality
Technical guardrails that keep an ambitious personal project from turning into chaos.
TypeScript-First Architecture
Shared types across main, preload and renderer to reduce errors across app boundaries.
Focused Test Coverage
Tests for ingestion, grouping, release watch, image cache, download search, main services and database operations.
Provider-Safe Data Fetching
Update strategies designed to avoid unnecessary traffic toward external APIs.
Error Observability
Structured logging, persistent errors and explicit retries for critical data flows.
Performance Guardrails
Limited IPC payloads, paginated queries, reduced renderer state and heavy work kept in the main process/database.
Manifesto
Design Philosophy
Why Nimlat rejects anonymous minimalism while remaining a usable application.
Read the full manifesto
Nimlat is intentionally over-the-top in both features and visual identity. It is built to feel excessive, technical, bright, and unapologetically stylized.
There is a concept in videogame interface design called diegetic UI: instead of interacting only with abstract panels, the user interacts with elements that feel like part of the world itself. Nimlat is still a web application, but it deliberately leans in that direction. Its interface is not meant to feel like a flat document with buttons on top. It is meant to feel like a machine, a console, a system with presence.
This is in strong contrast with much of modern aesthetic culture. Architecture, art, product design, and digital interfaces are increasingly flattened, simplified, muted, optimized, and stripped of ornament, identity, and symbolic force. In software, this tendency appears as sterile minimalism: rounded rectangles, interchangeable layouts, safe icons, muted palettes, and interfaces designed to be frictionless above all else.
I spent years studying and practicing usability. I know how to create clean, simple, practical, highly usable interfaces. So why is Nimlat the opposite of that? Why does it prioritize visual effects, identity, and atmosphere over absolute simplicity?
There are several reasons. The fact that Nimlat is not a commercial product matters. The fact that its target users are expected to be technically competent also matters. But those factors are not what drove the decision to use a visual style so deliberately misaligned with the current mainstream.
The first honest reason is that Nimlat is also a showcase of technical ability. Simplifying an interface today by building it out of flat, high-contrast Material-style buttons and cards is overwhelmingly easy. Creating neon elements that flicker, glow, animate, and still behave correctly inside a real application is not. Nimlat was built both to satisfy a personal need and to demonstrate that I can create technically ambitious, polished, distinctive software.
The second honest reason is that I have a visceral rejection of the dominant modern aesthetic: sterile minimalism, pseudo-brutalist digital design, corporate uniformity, and the broader cultural flattening that affects architecture, art, product design, and software alike.
This rejection is not aimed only at web interfaces. If anything, modern software is the easiest case to justify, because simplicity and accessibility often serve real users with limited technical ability, limited patience, or specific impairments. The deeper objection is cultural and aesthetic: it is aimed at modern art, architecture, and design when sterility is chosen deliberately rather than imposed by budget, function, or accessibility.
This is especially visible when modern aesthetic choices are applied to European artistic and architectural heritage. When classical buildings are “modernized” by stripping away their character, when historical spaces are forced to host sterile contemporary interventions, or when cities with centuries of visual identity are interrupted by objects that visibly despise their surroundings, the result is not practicality. It is aesthetic vandalism disguised as progress.
A clear example is Venice’s Ponte della Costituzione: a modern glass-and-steel bridge inserted into one of the most historically and visually coherent cities in Europe. Whether one likes it or not, it represents exactly the kind of modern intervention I object to: not because it is new, but because it asserts its own sterile modernity against the identity of the breathable history around it.
Much of modern design feels like the cultural equivalent of dystopian housing blocks: practical, efficient, rectangular, stripped of ornament, stripped of identity, stripped of soul. It works, but it does not inspire. It is suitable for systems that treat people as drones: users to be guided, workers to be managed, attention units to be processed.
Nimlat is not merely reacting against modern web design. It is reacting against the broader soul-devouring aesthetic culture that produced it.
Art, architecture, and software should not merely reduce friction. They should also inspire the mind, awaken passion, and give form to identity. Practicality matters. Usability matters. Accessibility matters. But a world made only of practical, usable, flattened things is not a world fit for human beings. It is a world fit for obedient drones.
The purpose of Nimlat’s visual identity is to reject that. It is meant to be bright, excessive, technical, personal, and alive. It is meant to prove that software can have an actual soul without becoming unusable or inaccessible.
Nimlat is a small cry against the darkness: a demand that the world around us should not only function, but also burn with identity, meaning, and human energy.
