Your anime universe / One app

imlat

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

Buy me a coffee

No account and no middleman: your support arrives through a standard SEPA bank transfer.

QR TYPEEPC / GIROCODE

Generating the QR code…

Bank transfer details

Amount
Your choice
Account holder
Bank
BBVA
IBAN
SWIFT / BIC
Reference

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.

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

  1. Open MyAnimeList API clients. Sign in if MAL asks you to, then choose Create ID.
  2. Complete the form with these values:

    Values for the MyAnimeList form
    App NameNimlat
    App TypeotherNimlat is a desktop app and uses PKCE without a Client Secret.
    Client IDGenerated by MAL after submissionThis is the value to copy into Nimlat.
    Client SecretNot issued for App Type otherWith App Type other, MAL does not issue it and Nimlat does not request it.
    App DescriptionPersonal desktop app for managing and syncing an anime watch list
    App Redirect URLhttp://127.0.0.1:8765/callback
    Homepage URLhttps://www.nicolo-zanetti.com/projects/nimlat
    App Logo URLLeave blank
    Privacy Policy URLLeave blank
    Terms of Use URLLeave blank
    Commercial / Non-Commercialnon-commercial
    Name / Company NameYour name or MAL username
    Purpose of Usehobbyist
    API License and Developer AgreementSelect the agreement checkbox
  3. Submit the form.
  4. Re-open the client you just created. MAL should now display its Client ID; copy it.

In Nimlat — start the connection

  1. Now open Nimlat: Preferences > Watched > MyAnimeList panel.
  2. Paste the value copied from MAL into Client ID.
  3. Click “Connect MyAnimeList”.
  4. Enjoy.
Provider / AniList tokenAniList

Connect Nimlat to your AniList account without sharing your password or Client Secret.

In AniList — create the application

  1. Open the AniList developer settings, sign in and choose Create New Application.
  2. Complete the form with these values:

    Values for the AniList application
    NameNimlat
    Redirect URLhttps://anilist.co/api/v2/oauth/pinIt must match exactly, with no extra spaces.
    Client IDGenerated by AniList after you saveYou will use this value in Nimlat and in the URL in the next step.
    Client SecretDo not paste it into NimlatNimlat uses the Implicit Flow and does not need this value.
  3. Save the application.
  4. AniList will display the Client ID; copy it.

In Nimlat — request the token

  1. The connection uses AniList’s documented Auth Pin flow, so you can copy the token directly from an AniList page.
  2. Open Preferences > Watched > AniList.
  3. Paste the Client ID into AniList client ID.
  4. Click Request access token from AniList. Nimlat will open the correct address in your browser.
  5. Sign in to AniList if asked and authorize Nimlat.
  6. AniList will display an access token; copy the complete token.

In Nimlat — save the connection

  1. Paste the token shown by AniList into Access token or redirect URL.
  2. Click Save token. Nimlat verifies the connection before storing it.
  3. Enjoy
Provider / Browser sign-inSimkl

Connect Nimlat to your Simkl account without sharing your password or Client Secret.

In Simkl — create the application

  1. Open Create an app in Simkl and sign in if asked.
  2. Complete the form with these values:

    Values for the Simkl application
    NameNimlat
    DescriptionPersonal desktop app for managing and syncing an anime watch list
    Redirect URIhttp://127.0.0.1:8765/callbackIt must match exactly, with no extra spaces.
    Client IDGenerated by Simkl after you saveThis is the value to copy into Nimlat.
  3. Save the application.
  4. Simkl will display the Client ID; copy it.

In Nimlat — start the connection

  1. Open Preferences > Watched > Simkl.
  2. Paste the value copied from Simkl into Client ID.
  3. Click Connect Simkl.
  4. Sign in to Simkl if asked and authorize Nimlat. The connection will complete automatically.
  5. 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

  1. Open Preferences > Download and choose Add new provider.
  2. Give it a readable name. Choose Torrent for direct torrent listings or Index for broader search sites.
  3. Paste the complete search URL and put {query} where the site expects search text, for example https://example.com/search?q={query}.
  4. Save and leave the provider enabled. You can disable, edit or remove it at any time.
  5. 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.

  1. 01 / UIReact 19 renderer
  2. 02 / BOUNDARYTyped preload bridge
  3. 03 / DOMAINMain-process services and daemons
  4. 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.