aniyomiorg/aniyomi

Aniyomi is a media consumption application that manages libraries of manga and anime content through a modular extension system. It handles content discovery, local caching, and downloading via background jobs, while supporting torrent streaming and integration with external tracking services. The system provides a modern, Compose-based interface for browsing, reading, and watching, along with robust backup and preference management capabilities.

89 changes.

The project underwent a massive architectural overhaul, migrating the UI to Jetpack Compose and Voyager while replacing legacy data and dependency injection systems. This period also marked the expansion of the app's scope to include full anime support, featuring a new video player, torrent streaming, and integrations with numerous tracking services.

107 changes.

The project introduced comprehensive anime support, adding dedicated data models, domain logic, and UI screens for browsing, library management, and tracking. This expansion was accompanied by a major architectural shift, migrating the codebase to Kotlin Multiplatform and rewriting the user interface using Jetpack Compose with Material 3 components.

26 changes.

This period focused on a comprehensive redesign of the user interface, particularly for the video player and extension management, while introducing new features like torrent streaming, Jellyfin tracking, and an upcoming releases screen. Significant backend work included rewriting the migration system for data compatibility, restructuring the build logic, and adding core infrastructure for encrypted DNS and archive handling.

Users can now track their manga and anime progress with the Bangumi service. This change introduces the Bangumi tracker implementation, including API client, OAuth authentication, and search functionality, allowing users to sync their reading and watching status, scores, and episode/chapter counts with their Bangumi library.

app/src/main/java/eu/kanade/tachiyomi/data/track/bangumi · high confidence

Users can now track their Jellyfin media library progress within the app. This new integration synchronizes watched status and episode counts by communicating with the Jellyfin API, automatically handling authentication via the associated Jellyfin source extension and supporting status updates for series and individual items.

app/src/main/java/eu/kanade/tachiyomi/data/track/jellyfin · high confidence

Users can now sync their reading progress with a Kavita library. This change introduces the Kavita tracker implementation, including API client logic for authentication (JWT), progress updates, and series metadata retrieval, along with the necessary data models and network interceptors to handle communication with the Kavita server.

app/src/main/java/eu/kanade/tachiyomi/data/track/kavita, app/src/main/java/eu/kanade/tachiyomi/data/track/suwayomi · high confidence

Users can now track their reading progress with Komga, a self-hosted comic/manga server. This new integration allows automatic synchronization of read status and chapter progress, supports matching series via URL, and handles read-lists. The feature includes specific API handling for both v1 and v2 endpoints and ensures compatibility with Komga's data model.

app/src/main/java/eu/kanade/tachiyomi/data/track/komga · high confidence

Users can now track manga with the MangaUpdates service. This change introduces the MangaUpdates tracker implementation, including API client, authentication, and data transfer objects, allowing users to search for series, update reading status, and manage their lists within the app.

app/src/main/java/eu/kanade/tachiyomi/data/track/mangaupdates · high confidence

Users can now track anime and movies with the Simkl service. This change introduces the Simkl tracker implementation, including OAuth authentication, search functionality across anime, TV, and movie types, and synchronization of watch progress, ratings, and status updates.

app/src/main/java/eu/kanade/tachiyomi/data/track/simkl · high confidence

The app now includes a dedicated set of UI screens for browsing and managing anime sources and extensions, mirroring the existing manga functionality. This adds new Compose screens for viewing and filtering anime sources (including pinning and disabling), browsing anime content from specific sources with multiple display modes (grid/list), managing anime extension installations and updates, and filtering extensions by language. It also introduces screens for migrating anime entries and searching across anime sources globally, providing a complete anime-specific browsing experience within the extension system.

app/src/main/java/eu/kanade/presentation/browse/anime · high confidence

A new CrashScreen composable has been introduced to handle application crashes. This screen displays the exception details to the user and provides two actions: dumping the crash logs via CrashLogUtil or restarting the application. The UI utilizes the shared InfoScreen component and follows the app's material design theme.

app/src/main/java/eu/kanade/presentation/crash · high confidence

A new screen and screen model have been added to the manga migration flow, allowing users to view and select their favorite manga from a specific source during the migration process. The screen displays a sorted list of favorites for the given source ID, handles loading states, and shows an error toast if fetching favorites fails.

app/src/main/java/eu/kanade/tachiyomi/ui/browse/manga/migration/manga · high confidence

A new Compose UI component, StatsOverviewItem, has been added to the stats screen to display statistical data with a title, subtitle, and an optional icon. This component allows users to view key metrics in a structured, icon-accompanied format within the application's stats interface.

app/src/main/java/eu/kanade/presentation/more/stats/components · high confidence

This change introduces new UI screens that display usage statistics for anime and manga collections. The implementation adds specific screen content components for both media types, along with the underlying data models and state definitions required to present metrics such as library counts, completion status, total read/watch duration, and tracker scores.

app/src/main/java/eu/kanade/presentation/more/stats · high confidence

This change introduces the presentation layer for the new storage viewer feature. It adds a set of Compose UI components in the storage package, including a cumulative storage chart (CumulativeStorage) that visualizes storage usage by category, a category selector (SelectStorageCategory) for filtering by user-defined categories, and a list item component (StorageItem) that displays individual entries with their size and entry count, along with a delete confirmation dialog. The main screen content (StorageScreenContent) orchestrates these components to display the storage overview and list, supporting both mobile and tablet layouts.

app/src/main/java/eu/kanade/presentation/more/storage · high confidence

A new storage viewer has been added to the app, accessible via a dedicated Storage tab. This feature allows users to browse their downloaded anime and manga content, view storage usage statistics (size and entry count), filter by category, and delete specific downloads. The implementation includes separate screen models and UI tabs for anime and manga libraries, leveraging a shared base model to handle common storage state and category filtering logic.

app/src/main/java/eu/kanade/tachiyomi/ui/storage · high confidence

Users can now stream content via torrents using a new foreground service (TorrentServerService) that manages the torrent server lifecycle and displays a persistent notification. The app's home screen shortcuts have been updated to include direct access to the library, anime library, recent updates, recent reads, and catalogues, with corresponding icons and labels. Additionally, ProGuard rules have been significantly expanded to ensure compatibility with extensions, specifically preserving classes for kotlinx.serialization, RxJava, OkHttp, and other common dependencies to prevent runtime crashes in release builds.

app · high confidence

The Updates screen now includes a confirmation dialog that appears when a user attempts to delete updates. This dialog displays a specific message depending on whether the content being deleted consists of manga chapters or anime episodes, and provides standard OK and Cancel buttons to confirm or dismiss the action.

app/src/main/java/eu/kanade/presentation/updates · high confidence

The design system now includes utility functions to detect screen width breakpoints, enabling components to adapt their layout based on available space. New composables \isMediumWidthWindow()\ and \isExpandedWidthWindow()\ allow the UI to check if the current window width exceeds 600dp or 840dp respectively, facilitating responsive design patterns within the application.

app/src/main/java/mihon/core/designsystem · high confidence

The build system now includes a new Gradle task, LocalesConfigTask, which automatically generates the Android locale configuration file (locales\_config.xml). This task scans the project's common resources for string files, extracts the supported locale names, and writes the resulting XML configuration to the output resource directory, ensuring the app correctly declares its supported locales.

buildSrc/src/main/kotlin/mihon/buildlogic/tasks · high confidence

New screens have been added to the Advanced settings section, allowing users to selectively clear database entries for specific manga or anime sources. These screens display a list of sources with non-library items, support selecting or inverting selections, and provide a confirmation dialog before permanently deleting the associated data from the local database.

app/src/main/java/eu/kanade/presentation/more/settings/screen/advanced · high confidence

A new \DelayedAnimeTrackingStore\ has been introduced to handle anime tracking updates when the device is offline. This component stores queued tracking data in a private shared preference file named 'tracking\_queue', allowing users to update their anime progress (specifically the last episode seen) without an active internet connection. The store manages these queued items by adding, removing, and retrieving them, ensuring that tracking data is preserved and can be synchronized later.

app/src/main/java/eu/kanade/domain/track/anime/store · high confidence

A new background job, DelayedAnimeTrackingUpdateJob, has been introduced to handle delayed anime tracking updates. This job retrieves pending tracking items from a store, fetches the corresponding anime track data, and applies the last episode seen status via the TrackEpisode interactor. It is configured to run only when a network connection is available and uses exponential backoff with a 5-minute initial delay, retrying up to three times before failing. This ensures that tracking updates are processed reliably even if the network is temporarily unavailable or if there are transient errors during the update process.

app/src/main/java/eu/kanade/domain/track/anime/service · high confidence

A new \DelayedMangaTrackingStore\ class has been introduced to manage a local queue of manga tracking updates. This component stores pending tracking data (specifically track ID and last chapter read) in private shared preferences under the key 'tracking\_queue', allowing the application to batch or defer synchronization of reading progress with external tracking services.

app/src/main/java/eu/kanade/domain/track/manga/store · high confidence

A new macrobenchmark module has been added to measure app startup performance across cold, warm, and hot states, and to generate baseline profiles for AOT compilation. The suite includes \StartupBenchmark\ tests that compare startup times under different compilation modes (none, partial with baseline profile disabled/enabled, and full compilation), and a \BaselineProfileGenerator\ that automates a critical user path (launching the app, navigating to Manga, Updates, History, and Settings) to capture the necessary profiling data. This allows developers to verify that baseline profiles are effectively improving startup latency.

macrobenchmark · high confidence

New data models, AnimeTrackSearch and MangaTrackSearch, have been introduced to represent search results from external trackers. These classes extend the existing database track models and include additional fields specific to search contexts, such as authors, artists, cover URLs, summaries, and publishing details, enabling the application to display richer metadata when users search for series.

app/src/main/java/eu/kanade/tachiyomi/data/track/model · high confidence

The AniList integration has been expanded to support both manga and anime tracking, allowing users to sync their anime viewing progress and status alongside their manga reading data. Additionally, the tracker now offers flexible scoring options, letting users choose between 10-point, 100-point, 5-star, smiley, and 10-point decimal scales to match their preference and the AniList API's capabilities.

app/src/main/java/eu/kanade/tachiyomi/data/track/anilist · high confidence

The Anime Updates screen has been updated to allow users to select specific video qualities when downloading episodes. This is implemented via a new \EpisodeOptionsDialogScreen\ that is triggered from the updates list, giving users control over download settings before the episode is fetched.

app/src/main/java/eu/kanade/tachiyomi/ui/updates/anime · high confidence

The app now includes dedicated stats tabs for both anime and manga libraries. These new screens present an overview of library size, completion counts, and total watch/read duration, alongside breakdowns of global update item counts, started titles, local entries, and total episodes or chapters read versus downloaded. Additionally, the stats aggregate tracker data, showing the number of tracked titles, the count of logged-in trackers, and the mean score across all tracked items.

app/src/main/java/eu/kanade/tachiyomi/ui/stats/anime · high confidence

The app now includes dedicated screens for managing anime extensions and sources, allowing users to browse, install, update, and filter anime content providers. This change introduces the AnimeExtensionFilterScreen and AnimeExtensionsScreenModel to handle extension installation, updates, and language filtering, as well as the AnimeSourcesFilterScreen and AnimeSourcesScreenModel to manage source visibility, pinning, and language preferences. Users can now access these features via the Browse tab, with options to filter by language, trust extensions, and open extension websites in a WebView.

app/src/main/java/eu/kanade/tachiyomi/ui/browse/anime/extension · high confidence

The anime migration interface now allows users to selectively choose which data attributes to migrate, rather than applying a blanket migration. This change introduces a new \AnimeMigrationFlags\ component that dynamically generates a list of migration options based on the source anime's content. Users can now toggle specific flags including Episodes, Categories, Custom Covers, Custom Backgrounds, and the deletion of downloaded files. The system automatically detects the presence of custom covers/backgrounds and existing downloads to present only relevant options, ensuring a more controlled and customizable migration process for anime libraries.

app/src/main/java/eu/kanade/tachiyomi/ui/browse/anime/migration · high confidence

This change introduces a dedicated domain layer for anime sources, adding interactor classes to manage source visibility, pinning, and incognito settings. Users can now toggle individual anime sources on or off, pin specific sources to the top of the list, and filter sources by language. Additionally, an incognito mode feature is added, allowing users to hide specific anime extensions from browsing history or recommendations, with the system checking both global incognito preferences and per-extension incognito flags.

app/src/main/java/eu/kanade/domain/source/anime · high confidence

The app now includes a dedicated screen for migrating anime sources, allowing users to view available sources along with their favorite counts. This screen supports toggling between alphabetical and total-count sorting modes, as well as ascending and descending directions, with preferences persisted for future sessions. A help action is provided in the app bar to open the official source migration guide online. Selecting a source navigates to the specific migration screen for that source.

app/src/main/java/eu/kanade/tachiyomi/ui/browse/anime/migration/sources · high confidence

The application now initializes with Coil 3 for image loading, supports TLS 1.3 on older Android versions, and provides an AppInfo API for extensions to access version and supported image MIME types. Additionally, users can export their manga and anime library favorites to CSV files with customizable columns.

app/src/main/java/eu/kanade/tachiyomi · high confidence

The domain module has been reorganized with new models and interactors to support anime-specific functionality, including season tracking (SeasonAnime, SeasonDisplayMode), upcoming anime listings, and anime category management (create, delete, hide, rename, reorder). It also introduces a new extension store system for both anime and manga, allowing users to add, remove, and update extension repositories, alongside refined download filtering logic for chapters and episodes based on category and read/unseen status.

domain · high confidence

A new Upcoming screen has been added for both anime and manga, allowing users to browse titles by their expected release date. The interface features a calendar component for selecting specific months and days, with date headers displaying a badge that indicates the number of upcoming items for that day. Users can navigate between months using previous/next buttons and tap on individual items to view their details.

app/src/main/java/mihon/feature/upcoming · high confidence

The core-metadata module now includes serializable data classes (MangaDetails, AnimeDetails, ChapterDetails, EpisodeDetails) and a ComicInfo schema to standardize how metadata is structured and persisted. This provides the foundational types for local source metadata handling, enabling features like custom episode data and automatic ComicInfo.xml conversion in other parts of the application.

core-metadata · high confidence

The app now includes a specific screen for viewing anime history, implemented via the new \AnimeHistoryScreenModel\ and \AnimeHistoryTab\ components. This feature allows users to browse their watched anime history, search through entries, and manage records by removing individual items or clearing the entire history. The screen also supports actions such as marking anime as favorites, moving them to specific categories, and resuming playback from the last seen episode.

app/src/main/java/eu/kanade/tachiyomi/ui/history/anime · high confidence

The app now includes a specific UI for managing manga reading history, replacing the previous generic implementation. This new screen allows users to search their history, view entries grouped by date, and perform actions such as removing individual or all history entries. It also integrates category management, enabling users to move manga between categories directly from the history view, and handles duplicate manga detection with options to migrate or view the existing entry.

app/src/main/java/eu/kanade/tachiyomi/ui/history/manga · high confidence

Users can now search across all enabled manga sources simultaneously from a new global search screen. The feature allows filtering results by specific extensions or source categories, and intelligently navigates directly to a manga detail page if the search yields exactly one result, reducing taps for common queries. The search interface supports real-time query updates and respects user preferences for pinned sources and language filters.

app/src/main/java/eu/kanade/tachiyomi/ui/browse/manga/source/globalsearch · high confidence

The app now features a dedicated 'More' tab that consolidates access to settings, downloads, categories, stats, and storage management, including a new player settings screen. A new onboarding flow has been added to guide first-time users, preventing accidental exit before completion and offering a direct path to restore backups. Additionally, a new screen handles new app updates, allowing users to view changelogs and initiate downloads directly from the interface.

app/src/main/java/eu/kanade/tachiyomi/ui/more · high confidence

Adds the Android implementation of the anime source manager, which now handles initialization by collecting installed extensions and registering local and stub sources, while providing extension functions to retrieve source icons, generate preference keys, and determine if a source is local, a stub, or used for torrent streaming.

app/src/main/java/eu/kanade/tachiyomi/source/anime · high confidence

A new SharedPreferencesDataStore class has been added to bridge Android's SharedPreferences with the AndroidX Preference library. This allows UI preference screens to read and write settings directly to shared preferences using standard AndroidX components, simplifying how user configuration data is persisted and accessed within the app.

app/src/main/java/eu/kanade/tachiyomi/data/preference · high confidence

This change adds the core domain-layer interactors and models required to handle anime and manga content items. For manga, it introduces \SetReadStatus\ (which marks chapters as read/unread and can automatically delete downloads based on preferences), \SyncChaptersWithSource\ (to fetch, add, update, and remove chapters from the local database), \GetAvailableScanlators\, and \ChapterFilter\ logic. A parallel set of components is added for anime, including \SetSeenStatus\ (handling seen/unseen status and download cleanup), \SyncEpisodesWithSource\ (synchronizing episodes with the source), and \EpisodeFilter\ logic. These files establish the backend behavior for item synchronization, status management, and filtering for both content types.

app/src/main/java/eu/kanade/domain/items · high confidence

The application now maintains distinct SQLite databases for manga and anime content, wiring them through new \AppModule\ and \PreferenceModule\ dependency injection files. This change adds specific database handlers and schema definitions for anime entities (such as \Animes\, \Episodes\, and \Animehistory\) alongside the existing manga structures, enabling the app to track and store anime-specific data independently.

app/src/main/java/eu/kanade/tachiyomi/di · high confidence

A new HistoriesTab component has been added to the application, providing a dedicated entry point for viewing manga and anime history. This tab features an animated icon that changes state based on selection and dynamically adjusts its position in the bottom navigation bar depending on user settings (specifically supporting the MOVE\_HISTORY\_TO\_MORE and MOVE\_BROWSE\_TO\_MORE navigation styles). The tab content utilizes a TabbedScreen to display separate Manga and Anime history lists, each with its own search functionality, and signals readiness to the main activity upon loading.

app/src/main/java/eu/kanade/tachiyomi/ui/history · high confidence

The application now includes a new \AnimeExtensionManager\ component located in the \app/src/main/java/eu/kanade/tachiyomi/extension/anime\ directory. This manager handles the lifecycle of anime-specific extensions, including loading installed extensions, fetching available extensions from a remote API, and managing installation and updates. It introduces a security model where extensions must be signed and trusted before being loaded, prompting users if an extension is untrusted. Additionally, it automatically enables relevant sub-languages for the device's locale during the first run to improve content discoverability.

app/src/main/java/eu/kanade/tachiyomi/extension/anime · high confidence

The application now supports fetching and managing manga extensions from external repositories. This change introduces the \MangaExtensionApi\ class, which retrieves available extensions by parsing \index.min.json\ files from configured repo URLs, validates them against minimum and maximum library version requirements, and checks for updates by comparing installed extension versions against those available in the repositories. Users will see update prompts for manga extensions when newer versions or library updates are detected.

app/src/main/java/eu/kanade/tachiyomi/extension/manga/api · high confidence

The reader UI now includes a dedicated ChapterNavigator component that displays page progress with a slider and navigation buttons, featuring reduced horizontal padding on smaller screens and haptic feedback during slider interaction. Additionally, a ModeSelectionDialog component has been added to reading mode and orientation selection dialogs, providing distinct 'Apply' and 'Revert to Default' buttons for clearer user control over settings.

app/src/main/java/eu/kanade/presentation/reader/components · high confidence

Added CheckboxState.asToggleableState() to map tri-state preference values to Compose's ToggleableState, and introduced Preference.asState() to bind a Preference directly to a Compose MutableState, enabling reactive UI updates when preference values change.

app/src/main/java/eu/kanade/core/preference · high confidence

A new Data Saver utility has been added to the application, allowing users to compress manga images before they are displayed to save mobile data. This feature supports three compression providers: Bandwidth Hero (with configurable server, quality, and format options), Wsrv.nl (supporting WebP/JPEG conversion and quality settings), and ReShush.it (using a remote API for compression). Users can configure these settings via preferences, including options to ignore specific image formats like JPEG or GIF, and can exclude specific sources from data saving.

app/src/main/java/aniyomi · high confidence

A new \aniyomi.lua\ script has been added to the application assets, exposing a set of Lua functions that allow external scripts to interact with the player. Users can now control playback (pause, unpause, seek by/to), switch episodes, and manage the UI (show/hide/toggle UI, subtitles, audio/video settings, and software keyboard). Additionally, the script introduces functions to configure and control custom on-screen buttons, including setting titles, showing, hiding, or toggling them.

app/src/main/assets · high confidence

The app introduces a new internal video player built on the mpvKt library, replacing the previous implementation. This change brings a complete rewrite of the player UI and controls using Jetpack Compose, including new dialogs for episode lists and settings. It also adds support for Picture-in-Picture mode with remote actions, hardware decoding options, video filters (brightness, saturation, etc.), and improved subtitle and audio track handling.

app/src/main/java/eu/kanade/tachiyomi/ui/player · high confidence

A new MangaExtensionManager has been introduced to handle the retrieval, installation, updating, and removal of manga extensions distributed as separate APKs. This component manages the lifecycle of these extensions, including loading installed sources, fetching available updates from a remote API, and enforcing signature-based trust checks to prevent malicious distribution. It also includes logic to automatically enable relevant sub-languages for users on their first run based on available sources.

app/src/main/java/eu/kanade/tachiyomi/extension/manga · high confidence

A new MangaDownload data class has been introduced in the download manga model package to manage the state and progress of individual manga downloads. This model aggregates source, manga, and chapter data while exposing reactive flows for download status (e.g., not downloaded, queue, downloading, downloaded, error) and real-time progress percentages. It also provides utility properties to calculate total progress and count of ready images, facilitating more granular tracking of the download process within the application.

app/src/main/java/eu/kanade/tachiyomi/data/download/manga/model · high confidence

This change introduces a new set of Compose UI components for the anime browsing experience. It adds a toolbar for anime sources that supports switching between list, compact grid, and comfortable grid display modes, as well as a toolbar for global anime search featuring source filters (pinned, all) and a results filter. The entry also includes components for displaying anime source items (with language support), icons for extensions and local sources, and grid/list layouts for browsing anime within a source, along with a horizontal card row for global search results.

app/src/main/java/eu/kanade/presentation/browse/anime/components, app/src/main/java/eu/kanade/presentation/browse/manga/components · high confidence

The app introduces several new domain model enums to support updated UI configuration options. AppTheme now includes additional visual styles such as Nord, Cotton Candy, Mocha, and Monet, alongside deprecated legacy options. NavStyle allows users to customize the bottom navigation bar by moving specific tabs (Manga, Updates, History, or Browse) into the 'More' menu. StartScreen defines which tab is shown on launch, while TabletUiMode and ThemeMode provide controls for tablet-specific layout behavior and light/dark system theming respectively.

app/src/main/java/eu/kanade/domain/ui/model · high confidence

The app introduces a new dedicated screen and associated model for viewing individual anime entries, replacing the previous implementation. This change includes the \AnimeScreen\ and \AnimeScreenModel\ classes which handle the display of anime details, episodes, and related data, along with \AnimeImageScreenModel\ for managing cover and background images. The new screen supports features like episode swiping, tracking, and season management, providing a more structured and feature-rich user experience for anime details.

app/src/main/java/eu/kanade/tachiyomi/ui/entries/anime · high confidence

Users can now view detailed information for installed anime extensions and configure individual source settings. This change introduces the AnimeExtensionDetailsScreen, which displays extension metadata, lists available sources with options to enable/disable them individually or in bulk, manage incognito mode, clear cookies, and uninstall the extension. It also adds the AnimeSourcePreferencesScreen, allowing users to access and modify specific configuration preferences for each anime source via a fragment-based UI integrated into the Compose navigation stack.

app/src/main/java/eu/kanade/tachiyomi/ui/browse/anime/extension/details · high confidence

The app now includes a dedicated search screen for migrating anime entries between sources. This feature allows users to search for a new source and initiate a migration dialog where they can select which data (such as episodes, tracks, or categories) to transfer from the old entry to the new one. The implementation includes specific UI components for the search results, the migration dialog itself, and the underlying screen models to handle the state and logic for this process.

app/src/main/java/eu/kanade/tachiyomi/ui/browse/anime/migration/search, app/src/main/java/eu/kanade/tachiyomi/ui/browse/manga/migration/search · high confidence

Users can now migrate anime entries between sources with support for selecting specific seasons. This change introduces a new migration screen that lists a source's favorites, allowing users to initiate a migration dialog where they can choose to migrate the entire series or select individual seasons for transfer.

app/src/main/java/eu/kanade/tachiyomi/ui/browse/anime/migration/anime · high confidence

The app introduces a dedicated screen for browsing anime sources, allowing users to view content via 'Popular' and 'Latest' listings and apply source-specific filters. This change adds the BrowseAnimeSourceScreen, its associated screen model for managing state and data paging, and a SourceFilterAnimeDialog that supports various filter types such as checkboxes, text inputs, selections, and sorting options.

app/src/main/java/eu/kanade/tachiyomi/ui/browse/anime/source/browse · high confidence

The app introduces a new UI component for managing anime tracking services. A new \AnimeTrackItem\ data class models the relationship between a tracked anime entry and its associated tracker service. Additionally, a new \AnimeTrackInfoDialog\ screen model and composable are added, providing a dedicated interface for users to view and edit tracking details such as status, episodes, score, and start/end dates, as well as perform actions like searching, copying links, and removing tracks.

app/src/main/java/eu/kanade/tachiyomi/ui/entries/anime/track, app/src/main/java/eu/kanade/tachiyomi/ui/entries/manga/track · high confidence

Added four new domain interactor classes in the anime tracking package: AddAnimeTracks handles binding new tracks and auto-matching enhanced trackers; RefreshAnimeTracks fetches updated data from all logged-in trackers; SyncEpisodeProgressWithTrack updates local episode seen status based on remote track progress; and TrackEpisode handles immediate or delayed episode tracking updates. These classes provide the core logic for anime tracking synchronization.

app/src/main/java/eu/kanade/domain/track/anime/interactor · high confidence

This update introduces a suite of new Compose UI components for the anime section, including \AnimeEpisodeListItem\ for displaying episode details with swipe actions and download indicators, \AnimeSeasonListItem\ for browsing anime by season, and \RelatedAnimeRows\ for showing connected titles. It also adds \AnimeInfoHeader\ for the main anime info display, \AnimeImagesDialog\ for managing covers and backgrounds, \BaseAnimeListItem\ as a shared list item template, and \EpisodeDownloadIndicator\ for visualizing download states. These components provide the visual foundation for the new anime entry screens.

app/src/main/java/eu/kanade/presentation/entries/anime/components · high confidence

A new AppLanguageScreen has been added to the appearance settings, allowing users to select the application language from a list derived from the project's locale configuration. The implementation displays the localized name of each language and, if that name is empty, falls back to showing the non-localized (English) display name, ensuring all available languages are visible and selectable.

app/src/main/java/eu/kanade/presentation/more/settings/screen/appearance · high confidence

A new UnlockActivity has been introduced to handle app unlocking via biometric prompts. This activity leverages the AuthenticatorUtil to initiate authentication and calls SecureActivityDelegate.unlock() upon success, providing a dedicated UI flow for verifying user identity to access the app.

app/src/main/java/eu/kanade/tachiyomi/ui/security · high confidence

The app introduces dedicated cache classes (AnimeBackgroundCache, AnimeCoverCache, ChapterCache, MangaCoverCache) to manage local storage of anime/manga covers, backgrounds, and chapter page lists. These classes handle saving, retrieving, and deleting cached files using MD5 hashes for filenames, with fallback to internal storage if external storage is unavailable. ChapterCache specifically uses DiskLruCache for efficient image and page list caching.

app/src/main/java/eu/kanade/tachiyomi/data/cache · high confidence

Added new Compose-based screens (AnimeCategoryScreen and MangaCategoryScreen) that allow users to view, reorder, rename, hide, and delete categories. These screens replace the previous implementation with a modern UI featuring drag-and-drop reordering and specific actions for each category item, including the ability to hide categories from the library view.

app/src/main/java/eu/kanade/presentation/category · high confidence

A new \core:archive\ library has been added to provide low-level support for handling archive formats. It introduces \ArchiveReader\ and \ArchiveInputStream\ to read entries from archives (such as EPUBs) via memory-mapped file descriptors using the \libarchive\ native library. The module also includes \EpubReader\ to parse EPUB package documents and extract image paths, as well as \ZipWriter\ for creating ZIP archives. Convenience extension functions on \UniFile\ allow easy integration with the app's file system abstraction.

core/archive · high confidence

The core/common module now includes the foundational components for torrent streaming, featuring a custom bencode parser, torrent metadata helpers, and a local torrent server API with configurable proxy modes and tracker lists. Additionally, the networking layer has been expanded to support DNS over HTTPS (DoH) with a wide selection of providers (such as Cloudflare, Google, and Mullvad) to improve privacy and reliability, alongside new network utilities like a JavaScript engine for source evaluation and standardized HTTP exception handling.

core/common · high confidence

The app introduces four new custom widget classes to enhance user interaction and UI behavior. MinMaxNumberPicker restricts keyboard input to numbers and enforces min/max bounds defined in XML. TachiyomiTextInputEditText automatically applies the IME\_FLAG\_NO\_PERSONALIZED\_LEARNING flag when incognito mode is enabled to improve privacy. RevealAnimationView provides reusable circular reveal animations for showing and hiding views. ViewPagerAdapter offers a simplified base for ViewPager adapters, reducing boilerplate in screen implementations.

app/src/main/java/eu/kanade/tachiyomi/widget · high confidence

The application introduces new domain models to handle extension data more explicitly. MangaExtension now defines distinct sealed classes for Installed, Available, and Untrusted extensions, providing structured access to metadata such as version codes, language, NSFW status, and source lists. Additionally, MangaLoadResult standardizes the outcome of extension loading operations into Success, Untrusted, or Error states, improving type safety when processing extension packages.

app/src/main/java/eu/kanade/tachiyomi/extension/manga/model · high confidence

The Debug Info screen now includes two new entries: 'Backup file schema' and 'Worker info'. The Backup file schema screen displays the Protobuf schema of the backup model and allows users to copy it to the clipboard. The Worker info screen lists the status of background work tasks (enqueued, running, finished), including details like next scheduled run times and attempt counts, and also provides a copy-to-clipboard option for the full list.

app/src/main/java/eu/kanade/presentation/more/settings/screen/debug · high confidence

The app now features separate, dedicated Updates screens for Anime and Manga content. These new screens provide a unified interface for viewing recent updates, supporting multi-selection actions such as marking items as seen/read, bookmarking, downloading, and deleting. The UI includes pull-to-refresh functionality, fast scrolling, and visual indicators for download progress and watch/read progress, with items grouped by date for easier navigation.

app/src/main/java/eu/kanade/presentation/updates/anime · high confidence

A new UI screen has been added to display and manage anime downloads separately from manga. This feature introduces a dedicated tab in the download queue that groups active downloads by source, allowing users to view progress, reorder episodes within a series, and cancel individual or series-wide downloads through a context menu.

app/src/main/java/eu/kanade/tachiyomi/ui/download/anime · high confidence

This change introduces four new domain-layer interactors in the anime entries module: SetAnimeViewerFlags handles setting skip-intro lengths and next-episode airing data; SyncRelatedAnimeWithSource fetches and syncs related anime titles from sources with a 7-day cache; SyncSeasonsWithSource manages season synchronization, including recognition, updates, and removals; and UpdateAnime provides centralized methods for updating anime metadata, fetch intervals, and favorite status.

app/src/main/java/eu/kanade/domain/entries/anime/interactor · high confidence

This change introduces the \UpdateAnimeFromRemote\ interactor along with \RemoteAnimeEpisodeUpdate\ and \RemoteAnimeSeasonUpdate\ data models in the domain layer. The interactor provides methods to fetch and synchronize new episodes and seasons from remote sources, handling title updates, cover/background cache management, and integration with existing sync logic for episodes and seasons.

app/src/main/java/mihon/domain · high confidence

This change introduces a suite of new Compose UI components for the entry list interface, including the bottom action menu, toolbar, item headers, and cover images. The bottom action menu now supports anime-specific actions such as marking episodes as seen or adding filler marks, alongside standard manga actions like bookmarking. The toolbar has been updated to handle action mode selection and includes anime-specific options like changing intro skip length. Additionally, the item header and dialogs now distinguish between manga chapters and anime episodes/seasons, utilizing separate string resources and fetch types to provide a tailored experience for anime content.

app/src/main/java/eu/kanade/presentation/entries/components · high confidence

Users can now view detailed information for installed manga extensions, including a list of all sources contained within the extension. This screen allows users to enable or disable individual sources, toggle the entire extension's incognito mode, clear cookies for the extension's sources, and uninstall the extension entirely. Additionally, users can now access and modify the configuration settings for individual sources directly from this view via a new preferences screen.

app/src/main/java/eu/kanade/tachiyomi/ui/browse/manga/extension/details · high confidence

The history section now includes dedicated screens for both anime and manga, allowing users to view their watch and read history separately. The new AnimeHistoryScreen and MangaHistoryScreen display items grouped by date with fast scrolling, showing episode/chapter numbers and timestamps. Each history item includes options to resume, mark as favorite, or delete. Additionally, new confirmation dialogs (HistoryDeleteDialog and HistoryDeleteAllDialog) have been added to handle history deletion with options to reset progress.

app/src/main/java/eu/kanade/presentation/history · high confidence

The app now includes a dedicated in-app update mechanism. When a new version is detected, users receive a notification with options to download the update, view what's new, or cancel. The download runs as a foreground service, providing progress updates and allowing cancellation. Once downloaded, a final notification prompts the user to install the APK. This replaces the previous behavior where update checks might have been less integrated or relied on different notification patterns.

app/src/main/java/eu/kanade/tachiyomi/data/updater · high confidence

The application introduces two new domain interactors to handle specific source preference operations. SetMigrateSorting allows users to configure the sorting mode (alphabetical or total) and direction (ascending or descending) for the migration screen. ToggleLanguage provides a mechanism to add or remove specific languages from the enabled languages list, simplifying the logic for toggling language visibility in source browsing.

app/src/main/java/eu/kanade/domain/source/interactor · high confidence

The presentation-widget module now includes new Glance-based widgets for both manga and anime updates. Users can add these widgets to their home screen to view a grid of recent updates, or to the lock screen (cover screen) for quick access. The widgets display cover art for recent items and handle app-lock states by showing a locked message when the app is secured. They are built using the Glance framework and Coil3 for image loading, with specific configurations for Samsung cover screens.

presentation-widget · high confidence

This change introduces a suite of new Compose UI screens for the manga browsing and extension management areas. Users can now browse manga sources with support for comfortable, compact, and list display modes, including pinning sources and viewing latest updates. A new global search interface allows filtering results by source and displaying them in a grouped list. Extension management is enhanced with dedicated screens for listing, filtering by language, viewing details (including incognito mode and repository links), and handling installation updates. Additionally, migration workflows now have dedicated screens for selecting sources and searching for manga to migrate, with sorting options and source count badges.

app/src/main/java/eu/kanade/presentation/browse/manga · high confidence

The app introduces a new UI for managing manga extensions, including a dedicated filter screen to toggle language availability and an updated main extensions tab. Users can now filter extensions by language, search by source name or ID, and view pending updates. A key behavioral change is the addition of a confirmation dialog when attempting to remove privately installed extensions, preventing accidental uninstallation. The interface also supports opening extension websites in a WebView and managing extension trust status.

app/src/main/java/eu/kanade/tachiyomi/ui/browse/manga/extension · high confidence

The app introduces a new notification system with dedicated classes for managing pending intents, receiving actions, and defining channels. This includes support for manga and anime downloads, library updates, backup/restore, and app updates, with specific channels for progress, errors, and completions. The system also handles actions like pausing/resuming downloads, marking chapters as read, and sharing images.

app/src/main/java/eu/kanade/tachiyomi/data/notification · high confidence

The player now features a set of new bottom-sheet UI components for managing playback options. Users can select audio and subtitle tracks, manage chapters, adjust playback speed with presets, and change video quality or hosters. Additional sheets allow for taking screenshots with options to set as cover or background, and a comprehensive 'More' sheet for decoder selection, sleep timers, and filters. These sheets provide a consistent, modern interface for accessing detailed player controls.

app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets · high confidence

The player settings interface now uses a new set of Compose UI components, including an expandable card for collapsible sections, a dropdown menu for selection, numeric and tinted sliders for value adjustment, a draggable bottom sheet for the settings panel, and toggle switches. These additions provide a more interactive and visually consistent experience for adjusting playback preferences.

app/src/main/java/eu/kanade/presentation/player · high confidence

This change introduces three new utility classes in the player utils package to enhance video playback features. AniSkipApi adds support for fetching opening and ending skip times from the AniSkip API and resolving MAL IDs via AniList, enabling automatic skipping of non-content segments. ChapterUtils provides logic to merge external timestamp data (such as AniSkip results) with existing player chapters, handling edge cases like adjacent segments and empty chapters to create a seamless chapter list. TrackSelect implements logic for automatically selecting preferred audio or subtitle tracks based on user-configured language preferences, whitelists, and blacklists, falling back to system default locale if no match is found.

app/src/main/java/eu/kanade/tachiyomi/ui/player/utils · high confidence

The presentation-core module has been introduced to centralize shared UI components and utilities. This includes a comprehensive set of Material 3 composables such as AdaptiveSheet, Badges, CollapsibleBox, LabeledCheckbox, and WheelPicker, alongside layout helpers like LazyColumnWithAction and TwoPanelBox. The module also provides utility functions for paging and fast scrolling, establishing a unified design system for the application.

presentation-core · high confidence

The reader module now includes a new set of model classes to manage reading state and transitions. \ReaderChapter\ tracks the loading state of a chapter (Wait, Loading, Error, Loaded) and handles resource recycling via reference counting. \ReaderPage\ and \InsertPage\ represent individual pages, with \InsertPage\ ensuring pages are marked as ready. \ChapterTransition\ defines navigation between chapters (Previous/Next) and includes equality logic to handle symmetric transitions. \ViewerChapters\ manages the set of chapters currently held in memory, coordinating reference counting for the current, previous, and next chapters to optimize memory usage.

app/src/main/java/eu/kanade/tachiyomi/ui/reader/model · high confidence

The reader now supports multiple tap-zone layouts for navigating pages, including Edge, Kindlish, L-shaped, and Right/Left configurations, as well as a Disabled option that removes all tap navigation. These changes allow users to choose a navigation style that best fits their reading preference or device ergonomics.

app/src/main/java/eu/kanade/tachiyomi/ui/reader/viewer/navigation · high confidence

The app now includes dedicated settings screens for browsing and managing extension sources for both anime and manga content. Users can add, remove, and refresh extension repositories directly from these new UI screens, with specific handling for anime extension stores and manga extension repos, including confirmation dialogs for adding new sources and conflict resolution for duplicate repositories.

app/src/main/java/eu/kanade/presentation/more/settings/screen/browse · high confidence

The Manga Sources screen now includes a filter action that opens a dedicated filter screen, allowing users to toggle individual manga sources and languages on or off. Additionally, if the app's global data saver mode is enabled, users can exclude specific sources from data saving via the source options dialog.

app/src/main/java/eu/kanade/tachiyomi/ui/browse/manga/source · high confidence

This change introduces a suite of new domain interactors in the manga source layer to handle source visibility and preferences, including GetEnabledMangaSources, GetLanguagesWithMangaSources, GetMangaIncognitoState, and GetMangaSourcesWithFavoriteCount. It adds ToggleMangaSource, ToggleMangaSourcePin, and ToggleMangaIncognito for managing source enablement, pinning, and incognito modes. A key behavioral addition is the ToggleExcludeFromMangaDataSaver interactor and the corresponding isExcludedFromDataSaver property on sources, allowing users to exclude specific sources from data saver mode. The Source model is also extended with a helper to retrieve the app icon as an ImageBitmap.

app/src/main/java/eu/kanade/domain/source/manga · high confidence

The app now includes a dedicated screen for migrating manga sources, allowing users to view available sources along with their favorite counts. This screen supports toggling between alphabetical and total-count sorting modes, as well as ascending and descending directions, with preferences persisted for future sessions. A help button is provided to open the official source migration guide.

app/src/main/java/eu/kanade/tachiyomi/ui/browse/manga/migration/sources · high confidence

The app now presents a multi-step onboarding experience covering theme selection, storage location configuration, and permission requests. Users can choose their app theme and dark mode, select a storage directory (with automatic folder creation on Android TV), and explicitly grant permissions for installing apps, notifications (Android 13+), and battery optimization exemptions. A final step provides links to a getting-started guide and a backup restore option, helping new users set up the app correctly while assisting returning users in restoring their data.

app/src/main/java/eu/kanade/presentation/more/onboarding · high confidence

The app introduces a new set of utility classes and Kotlin extensions in the system package to standardize access to device capabilities. This includes a new \AuthenticatorUtil\ for handling biometric and device credential authentication, \AnimationExtensions\ to respect the user's system animation speed settings, and \DeviceUtilExtensions\ to detect dynamic color availability. Network connectivity is now managed via \NetworkExtensions\ and \NetworkStateTracker\ for more robust online/offline detection, while \NotificationExtensions\ centralizes notification creation and permission checks. Additional helpers cover clipboard operations, intent sharing, tablet UI mode preparation, and safe foreground service transitions for background workers.

app/src/main/java/eu/kanade/tachiyomi/util/system · high confidence

A new TrackLogoIcon composable has been added to the track presentation components, displaying the logo for a specific tracker service. This component supports both click and long-press interactions, laying the groundwork for future actions such as copying tracker URLs. A corresponding preview provider has also been added to enable Android Studio previews for this component.

app/src/main/java/eu/kanade/presentation/track/components · high confidence

The app introduces several new utility components in the util package to support enhanced functionality. AniChartApi provides a new mechanism to fetch next episode airing times by querying AniList, MyAnimeList, and Simkl APIs, enabling features like next episode countdowns. CrashLogUtil replaces the previous crash notification approach with a direct file-sharing mechanism that dumps detailed debug information (including app version, device details, and problematic extension status) into a text file for user sharing. Additionally, new extension files (AnimeExtensions, MangaExtensions) standardize how covers and backgrounds are edited and cached for both local and remote media, while PkceUtil adds support for PKCE code verifiers, likely for secure API authentication.

app/src/main/java/eu/kanade/tachiyomi/util · high confidence

A new extension function has been added to the storage utilities that allows a BufferedSource to be saved directly to a File or an OutputStream. This utility automatically creates necessary parent directories, handles resource closing, and ensures that if an error occurs during the write process, the source is closed and the destination file is deleted to prevent partial or corrupted data.

app/src/main/java/eu/kanade/tachiyomi/util/storage · high confidence

This update introduces several new utility files in the core utilities module to support UI and data handling. It adds Composable functions \ifAnimeSourcesLoaded()\ and \ifMangaSourcesLoaded()\ to check if respective source managers are initialized, aiding UI readiness checks. New collection helpers \insertSeparators\ and \insertSeparatorsReversed\ allow inserting separators between list items, while \fastFilterNot\, \fastPartition\, and \fastCountNot\ provide optimized operations for lists known to support random access. Additionally, \RxJavaExtensions\ provides a conversion from RxJava \Observable\ to Kotlin \Flow\, and \addOrRemove\ simplifies HashSet updates.

app/src/main/java/eu/kanade/core/util · high confidence

Added three new extension files in the view utilities package to standardize common UI patterns. \EditTextPreferenceExtensions.kt\ exposes a package-private listener getter for \EditTextPreference\. \ViewExtensions.kt\ introduces \setComposeContent\ helpers for \ComponentActivity\ and \ComposeView\ that automatically apply the app's theme and typography, a \popupMenu\ helper for inflating and showing popup menus, and an \isVisibleOnScreen\ check. \WindowExtensions.kt\ adds a \setSecureScreen\ function to toggle the secure flag on a window, supporting incognito mode requirements.

app/src/main/java/eu/kanade/tachiyomi/util/view · high confidence

Added two new listener classes to the widget package to simplify common Android UI interaction patterns. IgnoreFirstSpinnerListener wraps AdapterView.OnItemSelectedListener to ignore the initial selection event, preventing unwanted side effects during initialization. SimpleSeekBarListener provides a base class for SeekBar.OnSeekBarChangeListener with empty method implementations, allowing subclasses to override only the events they need.

app/src/main/java/eu/kanade/tachiyomi/widget/listener · high confidence

The app now handles deep links for both anime and manga by introducing dedicated activities and UI screens that resolve external URLs. When a user opens a link, the app identifies whether it targets anime or manga, resolves the content via the appropriate source manager, and navigates directly to the specific entry or, if a chapter/episode ID is present, launches the corresponding player or reader activity immediately.

app/src/main/java/eu/kanade/tachiyomi/ui/deeplink · high confidence

The Manga data entity class has been deleted from the application's data layer. This removes the local data model that previously stored manga metadata such as title, author, source, and status via the StorIOSQLite library, indicating a structural change to how manga data is persisted or accessed.

app/src/main/java/eu/kanade/mangafeed/data/entities · high confidence

The \DetailHolder\ class, which previously rendered detail items using the \uk.co.ribot.easyadapter\ library, has been removed from the application. This change eliminates the boilerplate code responsible for displaying detail text and handling click-to-open URL actions for those specific list items, indicating a shift away from the previous adapter implementation.

app/src/main/java/eu/kanade/mangafeed/ui/adapter · high confidence

The legacy BaseActivity and MainActivity classes have been removed from the application. This cleanup eliminates the previous implementation that relied on manual back-stack management in the base activity and a character-focused main interface, paving the way for the new fragment-based architecture introduced in this change set.

app/src/main/java/eu/kanade/mangafeed/ui/activity · high confidence

The legacy DatabaseHelper, DbOpenHelper, and PreferencesHelper classes have been removed from the application. This cleanup eliminates the previous direct SQLite and SharedPreferences wrappers, indicating a shift in how data persistence and configuration are handled within the app's architecture.

app/src/main/java/eu/kanade/mangafeed/data/helpers · high confidence

The legacy database schema definitions for \CategoriesTable\, \ChaptersTable\, \MangasCategoriesTable\, and \MangasTable\ have been removed from the codebase. This cleanup eliminates the old SQL table creation logic and column constants, indicating a migration away from the previous data storage structure.

app/src/main/java/eu/kanade/mangafeed/data/tables · high confidence

Several utility classes in the app's util package have been removed as they are no longer used. This includes AndroidComponentUtil (for toggling components and checking services), DataUtils and NetworkUtil (for network connectivity checks), DialogFactory (for creating dialogs), SnackbarFactory (for creating snackbars), and ViewUtils (for pixel conversion).

app/src/main/java/eu/kanade/mangafeed/util · high confidence

The application now uses a dedicated domain module (DomainModule) to wire up interactor and repository implementations for manga, anime, extensions, and tracking features via the Injekt framework. This centralizes the binding of domain-layer logic, ensuring that services like chapter syncing, history management, and category handling are correctly instantiated and available to the rest of the app.

app/src/main/java/eu/kanade/domain · high confidence

The local source module has been converted to Kotlin Multiplatform, introducing \expect\/\actual\ class declarations in \commonMain\ for core components like \LocalAnimeSource\, \LocalMangaSource\, and their associated file system and image managers, with Android-specific implementations provided in \androidMain\. This structural change replaces direct file system access with a unified \UniFile\-based abstraction layer to support cross-platform compatibility.

source-local · high confidence

The DataModule class, which previously provided singleton instances of PreferencesHelper, DatabaseHelper, and the RxJava IO scheduler via Dagger, has been removed from the application. This change eliminates the legacy dependency injection setup for these core data helpers, indicating a shift in how the application manages its data layer dependencies.

app/src/main/java/eu/kanade/mangafeed/data · high confidence

The Manga model now includes several extension functions that enhance how manga data is handled and displayed. Users benefit from improved ComicInfo metadata generation, which now includes source name and publishing status details for better compatibility with external tools. Additionally, new helper functions allow for easier conversion between domain models and source models, and provide direct access to reading mode, orientation, and download filter states, streamlining the user experience when managing library filters and viewer settings.

app/src/main/java/eu/kanade/domain/entries/manga/model · high confidence

New extension functions have been added to the anime and manga domain models to handle conversion between the internal domain objects and the legacy database track models. For anime, \toDbTrack\ and \toDomainTrack\ facilitate the serialization and deserialization of tracking data (such as score, status, and dates), while \copyPersonalFrom\ allows copying personal tracking details between instances. The same pattern is applied to manga models, ensuring that user-specific tracking information is correctly preserved when migrating or syncing with the database layer.

app/src/main/java/eu/kanade/domain/track/anime/model, app/src/main/java/eu/kanade/domain/track/manga/model · high confidence

The Anime domain model now supports the new extension library 1.7 parameters, including season number and custom cover/background handling. Additionally, new filtering capabilities have been introduced for seasons, allowing users to filter anime seasons based on download status, unseen episodes, start/completion status, bookmarks, and filler marks, mirroring the existing episode-level filtering logic.

app/src/main/java/eu/kanade/domain/entries/anime/model · high confidence

The app now parses AniList API responses using a new set of data classes (DTOs) in the tracking module, replacing the previous parsing logic. This change introduces specific models for search results, user lists, authentication tokens, and media details (anime and manga), ensuring that nullable fields like status and format are handled correctly to prevent crashes. For users, this results in more reliable synchronization of reading/watching progress, scores, and library status with AniList, as the app now strictly maps the API's JSON structure to internal track objects.

app/src/main/java/eu/kanade/tachiyomi/data/track/anilist/dto · high confidence

The anime downloader has been migrated from a foreground service to Android's WorkManager. This change introduces a new set of classes in the download package (including AnimeDownloadJob, AnimeDownloadManager, and AnimeDownloadCache) to manage episode downloads. Users will experience more reliable background downloading that respects system constraints, automatic recovery of interrupted downloads after app restarts, and improved handling of network state (such as pausing downloads when Wi-Fi is required).

app/src/main/java/eu/kanade/tachiyomi/data/download/anime · high confidence

The anime entry screen has been rewritten in Kotlin using Jetpack Compose, introducing a new UI layout that supports seasons, related anime, and a next-episode countdown feature. Additionally, a new duplicate anime dialog has been added, allowing users to view the existing entry, migrate data, or add the duplicate anyway.

app/src/main/java/eu/kanade/presentation/entries/anime · high confidence

The extension update notification logic has been updated to explicitly specify the anime context when prompting users for updates. This ensures that tapping the notification opens the anime extensions section directly, rather than potentially opening the wrong or default tab.

app/src/main/java/eu/kanade/tachiyomi/extension/anime/api · high confidence

The anime library view has been completely rewritten to support multiple display modes (List, Compact Grid, Comfortable Grid, Cover Only Grid) with category tabs and a pager-based navigation system. A new settings dialog allows users to filter by status (downloaded, unseen, started, bookmarked, completed, tracker-synced) and sort by various criteria including airing time, last seen, and random. The UI now includes badges for downloads, unseen episodes, and language, along with a 'continue watching' action for entries with unseen content.

app/src/main/java/eu/kanade/presentation/library/anime · high confidence

The source-api module has been upgraded to extensions-lib 17, introducing several new features for anime sources. Sources can now provide related anime lists via the new \getRelatedAnimeList\ method and \supportsRelatedAnime\ flag. Video playback is enhanced with support for hosters, video timestamps, and thumbnail previews during seeking. Source preferences are now included in backups, and sources can be resolved directly from URIs via the new \ResolvableSource\ interface. Additionally, the API now supports an \UnmeteredSource\ interface for sources that do not require traffic considerations, and introduces a new \HttpServer\ model for extension use.

source-api · high confidence

The backup creation logic in the app module has been refactored from a monolithic structure into distinct, specialized creator classes (e.g., AnimeBackupCreator, MangaBackupCreator, PreferenceBackupCreator). This change introduces the ability to include private preferences in backups when explicitly requested, filters out empty source preferences to reduce backup size, and adds support for backing up extension stores and extension repositories. The refactoring also ensures that system categories are excluded from backups and that excluded scanlators are preserved for manga entries.

app/src/main/java/eu/kanade/tachiyomi/data/backup/create/creators · high confidence

The build logic in buildSrc has been reorganized into dedicated Kotlin files (AndroidConfig, BuildConfig, Commands, ProjectExtensions) to centralize build settings and improve maintainability. Android build targets are now explicitly defined in AndroidConfig, setting compile and target SDK to 36, minimum SDK to 26, and NDK to version 27.1.12297006. The Compose compiler plugin is now configured to use the OptimizeNonSkippingGroups feature flag, and build metrics/reports can be enabled via Gradle properties. Build metadata (commit count, SHA, build time) is now generated dynamically using Git commands. Build configuration flags for updater, code shrinking, and dependency info are exposed as project properties.

buildSrc/src/main/kotlin/mihon/buildlogic · high confidence

Source-related configuration options are now managed through the new SourcePreferences class, which consolidates settings for source display modes, language filters, NSFW visibility, migration sorting, pinned/hidden sources, and data saver preferences. This change extracts these preferences from the general PreferencesHelper, providing a dedicated interface for managing source-specific user choices.

app/src/main/java/eu/kanade/domain/source/service · high confidence

The app now uses a unified Compose-based theming system via the new TachiyomiTheme entry point, replacing the previous XML-based approach. This change centralizes color scheme management, supporting a wide variety of built-in themes (such as Nord, Mocha, and Monet) and allowing users to toggle AMOLED dark mode. It also introduces a specific, low-opacity ripple configuration for the media player to improve visual consistency.

app/src/main/java/eu/kanade/presentation/theme · high confidence

The new BaseActivity class now automatically applies the app theme and manages secure screen settings for all inheriting activities. This ensures consistent theming and security behavior across the app without requiring individual activity implementations to handle these concerns.

app/src/main/java/eu/kanade/tachiyomi/ui/base/activity · high confidence

The application's migration infrastructure has been completely rewritten to ensure seamless upgrades across multiple versions. This update introduces a broad suite of new migration scripts that handle significant changes to user preferences and data storage, including migrating library filters to tri-state logic, consolidating sorting modes and directions, and moving chapter and player preferences into dedicated preference stores. It also addresses behavioral shifts such as forcing MyAnimeList logouts due to authentication changes, cleaning up obsolete cache directories, standardizing external repository URLs, and removing legacy background job configurations. Additionally, the system now validates language codes for audio and subtitles and ensures that sensitive application state preferences are excluded from backups.

app/src/main/java/mihon/core/migration/migrations · high confidence

Users can now control whether the tracker updates automatically when marking chapters as read. A new setting allows choosing between always updating, asking for confirmation, or never updating, replacing the previous fixed behavior. This change also introduces a dedicated preferences class to manage these tracking settings alongside other tracker credentials and configuration options.

app/src/main/java/eu/kanade/domain/track/service · high confidence

The app now centralizes user interface configuration options—including theme mode, app theme, dark mode settings, relative time display, date format, tablet UI mode, start screen, and navigation style—into a new \UiPreferences\ class. This change provides a single, structured entry point for accessing and managing these display preferences, replacing scattered access patterns with a unified API backed by the preference store.

app/src/main/java/eu/kanade/domain/ui · high confidence

The app now intercepts uncaught exceptions via a new GlobalExceptionHandler, which serializes the crash details and launches a dedicated CrashActivity. This activity displays a CrashScreen UI component, allowing users to view the error and restart the app, rather than the app simply terminating or showing a generic system dialog.

app/src/main/java/eu/kanade/tachiyomi/crash · high confidence

The data module has been reorganized to include new repository implementations for anime extension stores, allowing the app to fetch and manage anime-specific extension repositories alongside existing manga support. Category handling for both anime and manga has been updated to support a 'hidden' flag, enabling users to hide categories from their library view. Additionally, the module now includes mappers and repositories for anime entries that support season-based organization and related entry tracking, while legacy anime extension repo formats are maintained for backward compatibility.

data · high confidence

The database layer for anime and manga content has been restructured to separate persistence models from domain logic. New interface-based models (AnimeTrack, Episode, Chapter, MangaTrack) and their corresponding implementations (AnimeTrackImpl, EpisodeImpl, ChapterImpl, MangaTrackImpl) have been introduced. These models now include explicit fields for tracking progress (such as last episode/chapter seen, scores, and dates) and provide conversion functions (toDomainEpisode, toDomainChapter) to map database records to domain objects, supporting updated tracking and synchronization features.

app/src/main/java/eu/kanade/tachiyomi/data/database · high confidence

The tracker system has been refactored to use a decoupled interface structure, introducing base and specialized interfaces (such as EnhancedAnimeTracker and EnhancedMangaTracker) that allow specific trackers to operate without manual user binding. This change enables 'enhanced' trackers like Jellyfin and Kavita to automatically match and migrate entries for compatible sources, streamlining the tracking experience for supported services while maintaining standard search-and-bind behavior for others.

app/src/main/java/eu/kanade/tachiyomi/data/track · high confidence

The app now uses a dedicated background worker (DelayedMangaTrackingUpdateJob) to handle delayed manga tracking updates. This job fetches pending tracking items, updates the read chapter status for each manga, and handles failures by retrying with exponential backoff or removing invalid entries. This ensures that tracking updates are processed reliably even if the network is unavailable or errors occur during the update process.

app/src/main/java/eu/kanade/domain/track/manga/service · high confidence

The backup creation process now supports granular control over what data is included, introducing new options to back up private settings and extension stores. Users can now choose to include non-library read entries and custom button configurations in their backups. The system also prevents creating backups if no valid options are selected and ensures that library entries are only backed up when explicitly enabled, while categories and other settings remain independent.

app/src/main/java/eu/kanade/tachiyomi/data/backup/create · high confidence

The global anime search screen now includes a toggle to filter results, showing only sources that returned matches. This behavior is driven by the new \AnimeSearchScreenModel\ and \GlobalAnimeSearchScreen\ in the \globalsearch\ package, which listen to the \globalSearchFilterState\ preference to update the displayed items accordingly.

app/src/main/java/eu/kanade/tachiyomi/ui/browse/anime/source/globalsearch · high confidence

The HTTP server functionality has been moved from the main application context into a dedicated \HttpServerService\. This ensures the server runs as a foreground service with a persistent notification, improving stability and allowing the server to continue operating even if the main app UI is closed or backgrounded.

app/src/main/java/eu/kanade/tachiyomi/data/player · high confidence

The category screen now uses new Material 3 Compose components for managing categories. Users can create, rename, and delete categories via dedicated dialog components that validate input and prevent duplicate names. The category list now features interactive list items with drag handles for reordering, and specific action buttons to rename, delete, or hide categories from the library view.

app/src/main/java/eu/kanade/presentation/category/components · high confidence

The backup restore process now allows users to selectively choose which data categories to restore, rather than restoring everything at once. Users can now toggle specific options including library entries, categories, app settings, extension stores, custom buttons, source settings, and extensions during the restore flow, providing finer control over what data is imported from a backup file.

app/src/main/java/eu/kanade/tachiyomi/data/backup/restore · high confidence

The reader experience has been overhauled with a new UI built using Jetpack Compose, replacing the previous XML-based layout. This update introduces a new navigation overlay system that visualizes tap zones for page turning, enhancing discoverability of reader controls. The new ReaderActivity and ReaderViewModel leverage modern Android architecture components, including ViewBinding and StateFlow, to manage reading state and progress more reliably. Additionally, the reader now supports a new notification system for saving images, providing users with immediate feedback and quick actions directly from the notification shade.

app/src/main/java/eu/kanade/tachiyomi/ui/reader · high confidence

The pager reading mode now uses a new implementation (Pager, PagerViewer, PagerConfig, etc.) that supports configurable navigation layouts (L, Kindlish, Edge, Right/Left, Disabled), dual-page splitting with rotation and inversion options, automatic background color extraction, and improved tap/long-tap handling with haptic feedback. This replaces the previous pager logic with a more modular, coroutine-based approach for page loading and status tracking.

app/src/main/java/eu/kanade/tachiyomi/ui/reader/viewer/pager · high confidence

The app now includes a new Android-specific implementation for managing manga sources (AndroidMangaSourceManager) and associated extension functions. This change introduces a mechanism to initialize and track manga sources based on installed extensions, handling the mapping between extension-provided sources and internal stub representations. It also adds utility functions for retrieving source icons, generating preference keys, and determining source names for display based on language preferences, as well as checking if a source is local or a stub.

app/src/main/java/eu/kanade/tachiyomi/source/manga · high confidence

The player now utilizes a new hoster abstraction for retrieving and playing video content. New loader classes (EpisodeLoader and HosterLoader) handle fetching hosters for episodes based on their source type (online, downloaded, or local) and manage the concurrent loading and selection of the best available video stream from those hosters, replacing the previous direct video-list retrieval logic.

app/src/main/java/eu/kanade/tachiyomi/ui/player/loader · high confidence

The migration UI now uses a dedicated \MangaMigrationFlags\ component to manage which data categories (chapters, categories, custom covers, and downloaded files) are included in a migration. This change introduces logic to dynamically determine available flags based on the specific manga's content (e.g., only showing custom cover options if a custom cover exists) and provides utilities to convert between user selections and internal bitmaps, ensuring that migration operations accurately reflect the source data's structure.

app/src/main/java/eu/kanade/tachiyomi/ui/browse/manga/migration · high confidence

The Kitsu integration has been completely rewritten to use a new HTTP client built on OkHttp and kotlinx.serialization, replacing the previous implementation. This change introduces automatic status updates: when you finish the last chapter or episode of a series, the tracker now automatically marks the entry as 'Completed' and sets the finish date. It also correctly sets the 'Started' date when you begin reading or watching for the first time. The update includes a new OAuth interceptor for token management, date formatting helpers, and utility functions to map internal statuses and scores to the Kitsu API format.

app/src/main/java/eu/kanade/tachiyomi/data/track/kitsu · high confidence

The Kitsu tracking integration now uses specific data classes to parse API responses, replacing previous parsing logic. This change introduces proper type handling for fields such as \ratingTwenty\ (now an integer instead of a string) and \synopsis\ (explicitly nullable), which improves reliability when syncing reading or watching progress and search results with the Kitsu service.

app/src/main/java/eu/kanade/tachiyomi/data/track/kitsu/dto · high confidence

The library screen implementation has been split into distinct Anime and Manga modules (e.g., \AnimeLibraryTab\, \MangaLibraryTab\, and their respective ScreenModels and Items). This change introduces separate state management, filtering, and sorting logic for each content type, allowing for independent configuration of library views, category tabs, and search behaviors for anime versus manga.

app/src/main/java/eu/kanade/tachiyomi/ui/library · high confidence

The manga library screen now uses a new set of Compose-based components (MangaLibraryContent, MangaLibraryPager, MangaLibraryList, MangaLibraryCompactGrid, MangaLibraryComfortableGrid) to render library items. This change introduces a pager-based navigation system for categories, replacing the previous custom pager implementation. Users will see updated visual layouts for list and grid display modes, with consistent badge rendering for downloads, unread status, and language. The library settings dialog has also been updated to support the new display modes and sorting options, including a random sort option.

app/src/main/java/eu/kanade/presentation/library/manga · high confidence

The Library screen's user interface has been rebuilt using Jetpack Compose, introducing new components for the toolbar, tabs, and entry items. Users will see a refreshed Library toolbar that displays entry counts in a pill badge, supports filtering, global updates, and random entry selection, and switches to a selection mode with bulk actions when items are selected. The category tabs now use Material 3's PrimaryScrollableTabRow with badge counts, and the library grid/list items feature updated layouts with cover overlays, 'Continue Viewing' buttons, and badges for downloads, unviewed status, and language.

app/src/main/java/eu/kanade/presentation/library/components · high confidence

The main application entry point has been completely rewritten using Jetpack Compose and the Voyager navigation library, replacing the previous Conductor-based architecture. This change modernizes the UI layer, enabling edge-to-edge display, improved system bar handling, and a more responsive navigation experience for the home, library, and browse screens.

app/src/main/java/eu/kanade/tachiyomi/ui/main · high confidence

The manga download queue screen has been rebuilt using a new adapter-based RecyclerView wrapped in a Compose AndroidView, replacing the previous implementation. This change introduces the ability to reorder individual chapters within a series by dragging them, as well as moving items to the top or bottom via context menus. Downloads are now grouped by source, displaying a header with the source name and total count, and the UI correctly handles nested scrolling and padding adjustments.

app/src/main/java/eu/kanade/tachiyomi/ui/download/manga · high confidence

The manga download service has been migrated from a foreground service to Android's WorkManager (MangaDownloadJob). This change means downloads are now managed by the system scheduler, which improves reliability by allowing the OS to restart downloads after device reboots or app crashes, and ensures better battery efficiency by respecting system constraints. The download queue and progress notifications remain functional, but the underlying execution model is now handled by WorkManager rather than a persistent foreground service.

app/src/main/java/eu/kanade/tachiyomi/data/download/manga · high confidence

The domain layer for manga entries has been restructured by introducing dedicated interactor classes to handle specific update and configuration tasks. Users benefit from a cleaner separation of concerns as operations like updating manga metadata from sources, managing excluded scanlators, setting viewer preferences (reading mode and orientation), and adjusting fetch intervals are now encapsulated in new classes such as UpdateManga, GetExcludedScanlators, SetExcludedScanlators, and SetMangaViewerFlags. This change also includes a migration to newer Java date/time APIs (java.time) for handling timestamps and intervals, ensuring more robust time-based calculations for manga updates.

app/src/main/java/eu/kanade/domain/entries/manga/interactor · high confidence

The app's theming engine has been migrated from XML-based themes to Jetpack Compose Material 3. This introduces a new \BaseColorScheme\ architecture that supports both light and dark modes, including a dedicated Amoled black mode for OLED screens. A suite of new built-in color palettes is now available, including Cloudflare, Cottoncandy, Doom, Green Apple, Lavender, Matrix, Midnight Dusk, Mocha, Monochrome, Nord, Sapphire, Strawberry, and Tako. Additionally, the Monet theme now dynamically generates color schemes based on the device's wallpaper seed color, with a compatibility layer for older Android versions.

app/src/main/java/eu/kanade/presentation/theme/colorscheme · high confidence

The More screen, New Update screen, and LogoHeader have been rewritten using Jetpack Compose. This migration introduces a modern UI with a ScrollbarLazyColumn for the main menu, SwitchPreferenceWidgets for toggles like Downloaded Only and Incognito Mode, and a unified layout for the New Update screen that displays changelogs via RichText. Users will see a consistent, updated visual style for these navigation and update interfaces.

app/src/main/java/eu/kanade/presentation/more · high confidence

The MyAnimeList integration has been rewritten to use the official MyAnimeList API, replacing the previous implementation. This change introduces support for reading/watching dates, automatically updates the tracker status to 'Completed' when the final chapter or episode is marked as read, and fixes issues where status updates failed if all content was already consumed. The search functionality now filters out novels from manga results and truncates queries to 64 characters to prevent API errors. Additionally, authentication has been hardened with proper token refresh handling and an Authorization header on refresh requests, ensuring more reliable login sessions.

app/src/main/java/eu/kanade/tachiyomi/data/track/myanimelist · high confidence

This update introduces a suite of new Compose-based components in the app's presentation layer to modernize the user interface. The new AppBar component provides a flexible top app bar with support for action modes, scroll behaviors, and custom titles. TabbedScreen and TabbedDialog replace previous implementations to offer consistent tabbed navigation with badge counts, search toolbars, and overflow menus. AdaptiveSheet and NavigatorAdaptiveSheet manage bottom sheets and dialog-like screens, handling swipe-to-dismiss and back navigation logic while adapting to tablet layouts. Additional components include Banners for displaying app state indicators (such as indexing or incognito mode), DropdownMenu for consistent menu styling, and EmptyScreen for standardized empty states. These changes collectively shift the app's UI foundation to a more cohesive Compose Material3 design.

app/src/main/java/eu/kanade/presentation/components · high confidence

The browse screen now uses a set of new Jetpack Compose components to render its interface. This includes a reusable base item layout for list entries, specific components for global search results (cards, loading states, and error displays), a dialog for removing entries, and visual badges indicating library status. These changes replace previous implementations with a modern Compose-based approach for the browse and search areas.

app/src/main/java/eu/kanade/presentation/browse · high confidence

The settings interface has been rewritten using Jetpack Compose, introducing a new modular architecture for preference screens. This change adds a reusable preference system (Preference.kt) supporting various item types including switches, sliders, lists, multi-select lists, text edits, and a specific MPV config editor. It also introduces a PreferenceScaffold for consistent layout and a PreferenceScreen that handles grouping, scrolling, and search highlighting, replacing the previous implementation with a modern, composable approach.

app/src/main/java/eu/kanade/presentation/more/settings · high confidence

The settings screen now uses a new set of Compose widgets in the \more/settings/widget\ package to render preference controls. This includes \AppThemeModePreferenceWidget\ for selecting system, light, or dark mode via segmented buttons, and \AppThemePreferenceWidget\ for choosing app themes with live previews and dynamic color filtering. A \BasePreferenceWidget\ provides a consistent layout with optional icons, titles, and trailing widgets, while specialized widgets like \ListPreferenceWidget\, \MultiSelectListPreferenceWidget\, \SwitchPreferenceWidget\, and \EditTextPreferenceWidget\ replace previous implementations with Material 3 dialogs and interactive components. These changes modernize the settings UI and improve consistency across preference types.

app/src/main/java/eu/kanade/presentation/more/settings/widget · high confidence

The video player controls have been completely rewritten in Jetpack Compose, replacing the previous implementation with a new layout structure. This update introduces a dedicated GestureHandler for intuitive swipe-based seeking, volume, and brightness adjustments, as well as double-tap to seek. The UI now features distinct control zones (TopLeft, TopRight, BottomLeft, BottomRight, Middle) that display playback speed, chapter info, custom buttons, and aspect ratio settings. Additionally, the player now supports video hosters, thumbnail previews during seeking, and a revamped set of bottom sheets for managing subtitles, audio tracks, and quality settings.

app/src/main/java/eu/kanade/tachiyomi/ui/player/controls · high confidence

The Manga detail view has been replaced with a new implementation (MangaScreen and MangaScreenModel) that introduces a dedicated MangaCoverScreenModel. This model handles cover-specific actions such as saving, sharing, editing, and deleting custom covers using the Coil3 image library, while the main screen now manages chapter lists, tracking, and library interactions with lifecycle-aware state collection.

app/src/main/java/eu/kanade/tachiyomi/ui/entries/manga · high confidence

The app introduces new database handler implementations for both anime and manga content, replacing previous storage mechanisms with SQLDelight-backed handlers. These new handlers (AndroidAnimeDatabaseHandler and AndroidMangaDatabaseHandler) provide structured access to the database via coroutines, supporting transactional operations, reactive flows for real-time updates, and efficient paging through QueryPagingAnimeSource and QueryPagingMangaSource. This change improves data consistency and performance by leveraging SQLDelight's type-safe queries and coroutine integration.

data/src/main/java/tachiyomi/data/handlers/anime, data/src/main/java/tachiyomi/data/handlers/manga · high confidence

The app now includes dedicated installers for anime extensions: a \PackageInstallerInstallerAnime\ that uses the standard Android PackageInstaller API (with fixes for Android 14+ and Android 15 API collisions), and a \ShizukuInstallerAnime\ that leverages Shizuku for privileged installs, including fixes for multi-user setups. These components handle the installation queue, session management, and cancellation logic specifically for anime extensions.

app/src/main/java/eu/kanade/tachiyomi/extension/anime/installer · high confidence

Added three new utility functions in the chapter utilities package to support chapter list management: \filterDownloadedChapters\ filters out non-downloaded chapters (respecting local manga status) for use with 'Downloaded Only' views; \removeDuplicates\ deduplicates the chapter list based on chapter number and scanlator to prevent duplicate entries during download operations; and \getNextUnread\ identifies the next unread chapter while applying current sorting and filtering rules, aiding navigation in the reader.

app/src/main/java/eu/kanade/tachiyomi/util/chapter · high confidence

The entry screen now defines specific constants for UI structure and user actions. A new DownloadAction enum allows users to select downloading the next 1, 5, 10, or 25 items, or all unviewed items. An EditCoverAction enum provides options to edit or delete a cover image. Additionally, an EntryScreenItem enum structures the screen layout into distinct sections including an info box, action row, description with tags, item header, individual items, and airing time.

app/src/main/java/eu/kanade/presentation/entries · high confidence

The backup restore process now uses specialized restorer classes for several data types that were previously handled by monolithic or generic logic. Restoring anime and manga categories now correctly maps backup category names to existing database entries and updates the categorized display settings. Extension repository configuration is restored via dedicated anime and manga restorers that handle upserts and validate signing key fingerprints to prevent conflicts. Additionally, custom player buttons are restored with proper sorting and favorite-flag handling, and the extension store index is restored for anime content. These changes ensure that category assignments, extension sources, and UI customizations are restored accurately and without duplication.

app/src/main/java/eu/kanade/tachiyomi/data/backup/restore/restorers · high confidence

The backup and restore workflows now use dedicated, full-screen interfaces instead of inline settings. The new Create Backup screen lets users select specific library, settings, and extension options to include, while the Restore Backup screen validates the backup file and allows selective restoration of content. Both screens display a prominent warning on MIUI devices and use a consistent UI with a bottom action button. A new Storage Info component also provides a visual breakdown of available disk space across external storages.

app/src/main/java/eu/kanade/presentation/more/settings/screen/data · high confidence

The app now uses a dedicated set of components to manage extension lifecycle: a foreground service (AnimeExtensionInstallService) handles background installation via PackageInstaller or Shizuku, while a broadcast receiver (AnimeExtensionInstallReceiver) detects system package changes to update the UI. A new installer class (AnimeExtensionInstaller) manages downloads and supports both legacy system prompts and a new private installation mode that stores extensions internally. Additionally, the loader (AnimeExtensionLoader) has been updated to support extension-lib versions 14.0, 16.0, and 17.0, and prioritizes shared system extensions over private ones.

app/src/main/java/eu/kanade/tachiyomi/extension/anime/util · high confidence

The app now uses a dedicated service, activity, and broadcast receiver to handle extension installation, updates, and removals. This change introduces a background service for managing downloads and installations (supporting both legacy package installer and private/shizuku modes), an activity to handle system install intents (with specific workarounds for MIUI), and a receiver to detect when extensions are installed, updated, or removed by the system or other apps, ensuring the app's internal state stays synchronized with the actual installed extensions.

app/src/main/java/eu/kanade/tachiyomi/extension/manga/util · high confidence

The extension installation process has been refactored to use a new queue-based installer system. This introduces a base \InstallerManga\ class that manages an installation queue and handles cancellation, alongside two concrete implementations: \PackageInstallerInstallerManga\ for standard Android package installation and \ShizukuInstallerManga\ which uses Shizuku to execute \pm\ commands for installation, addressing previous issues with multi-user setups. Users will experience a more robust installation flow with better handling of concurrent installs and improved stability when using Shizuku for privileged installations.

app/src/main/java/eu/kanade/tachiyomi/extension/manga/installer · high confidence

This change introduces new domain-layer interactors for managing anime and manga extensions, including \GetAnimeExtensionLanguages\, \GetMangaExtensionLanguages\, \GetAnimeExtensionSources\, \GetMangaExtensionSources\, \GetAnimeExtensionsByType\, and \GetMangaExtensionsByType\. These components handle fetching available extensions, filtering by language and NSFW preferences, and grouping extensions into updates, installed, available, and untrusted categories. Additionally, \TrustAnimeExtension\ and \TrustMangaExtension\ implement logic to verify extension trust status based on repository signing keys and user preferences, allowing users to trust extensions by their repository signature.

app/src/main/java/eu/kanade/domain/extension · high confidence

This change introduces a suite of new utility functions in the presentation layer to improve user experience and code consistency. Exception messages are now formatted with user-friendly, localized text for specific errors like network issues or missing sources. Fast scrolling in lists is smoother, avoiding visual jank when permissions are already granted. Navigation transitions between screens now use a consistent slide animation, and a new helper ensures package installation permissions are tracked correctly without blocking onboarding. Additionally, chapter and episode numbers are formatted consistently, and time spans are displayed in a more readable relative format.

app/src/main/java/eu/kanade/presentation/util · high confidence

The application introduces a new data model for full backups using protobuf serialization. This includes a \Backup\ class that organizes manga, anime, categories, sources, and preferences into distinct fields with specific protobuf numbers, and a \BackupPreference\ class that handles preference values as a sealed hierarchy supporting integers, longs, floats, strings, booleans, and string sets. This structural change replaces the previous backup format, ensuring that preferences and other backup data are serialized and deserialized using the new protobuf schema.

app/src/main/java/eu/kanade/tachiyomi/data/backup/full · high confidence

The app now uses a new protobuf-based backup format instead of the previous JSON format, while still supporting legacy backups for compatibility. A new validation step checks for missing sources and trackers before restoration begins. Backup and restore progress is now shown in separate notification channels, with clearer completion messages, error logs, and options to share or cancel the operation.

app/src/main/java/eu/kanade/tachiyomi/data/backup · high confidence

The reader now uses a new loader system where page loading is handled by specific loader classes (ArchivePageLoader, DirectoryPageLoader, DownloadPageLoader, EpubPageLoader, HttpPageLoader) that extend a common PageLoader base. This change introduces support for loading pages from various sources including local archives, directories, downloaded chapters, EPUB files, and online sources, with improved resource management through the recycle() method and better error handling for page loading operations.

app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader · high confidence

The app now uses a new BrowseMangaSourceScreen for browsing manga within a specific source, featuring a toolbar with search and display mode controls, and filter chips to switch between Popular and Latest listings. This screen integrates a new SourceFilterMangaDialog that allows users to apply, reset, and update various filter types (checkboxes, text, select, sort, and groups) directly within the browsing interface, replacing the previous browsing mechanism.

app/src/main/java/eu/kanade/tachiyomi/ui/browse/manga/source/browse · high confidence

The player settings have been reorganized into dedicated configuration classes (Advanced, Audio, Decoder, Gesture, Player, Subtitle) to provide more granular control over playback. Users now have specific settings for audio channels (including AutoSafe, Mono, Stereo, and ReverseStereo), video decoding options (hardware decoding, gpu-next, debanding, YUV420P), and gesture controls (volume/brightness sliders, double-tap actions, media controls). Subtitle customization has expanded to include font, size, color, border style, and justification. Additional features include intro skipping (AniSkip, Netflix-style), picture-in-picture options, and hoster display preferences.

app/src/main/java/eu/kanade/tachiyomi/ui/player/settings · high confidence

The track management UI now includes dedicated dialog components for selecting status, item counts (chapters/episodes), scores, and dates. These new selectors replace previous implementations, utilizing Material 3 components like the DatePicker and custom wheel pickers for score and item selection, while also integrating immutable collections and multiplatform string resources for better consistency and performance.

app/src/main/java/eu/kanade/presentation/track · high confidence

The player settings have been restructured into a main hub screen that links to dedicated sub-menus for specific configuration areas. This change introduces separate settings screens for internal player options (such as progress tracking, hosters, and display), audio controls (language, pitch correction, channels, volume boost), video decoding (hardware acceleration, debanding), gestures (seeking, double-tap, media controls), subtitles (language, whitelist/blacklist), advanced MPV options (user files, config editing), and torrent streaming (proxy mode, trackers). This provides a clearer, more navigable interface for managing player preferences.

app/src/main/java/eu/kanade/presentation/more/settings/screen/player · high confidence

The project has been rebranded from Mangafeed/Mihon to Aniyomi, reflected in the updated README, CHANGELOG, and CONTRIBUTING documentation. The Travis CI configuration has been removed, and the repository now includes a formal Code of Conduct, an Apache 2.0 LICENSE file, and standardized .editorconfig and .gitattributes files to enforce consistent coding styles and line endings across the codebase.

(repo-wide) · high confidence

The reader interface components in this package have been rewritten using Jetpack Compose, replacing the previous Android View implementations. This migration introduces a new chapter transition display that highlights downloaded chapters and warns about gaps between chapters, and adds a configurable white/black screen flash on page turns to improve visibility on e-ink displays. Additionally, the reader's page actions menu now includes an option to copy the current page to the clipboard, and the reading mode and orientation selection dialogs have been updated with separate default and apply buttons for clearer configuration.

app/src/main/java/eu/kanade/presentation/reader · high confidence

The reader's top and bottom app bars have been rewritten in Jetpack Compose, introducing slide-in/slide-out animations for visibility and proper handling of system bar insets in fullscreen mode. The bottom bar now groups reading mode, orientation, crop border, and settings controls into a single row, while the top bar displays the manga and chapter titles and provides actions for bookmarking, sharing, and opening in a browser or web view.

app/src/main/java/eu/kanade/presentation/reader/appbars · high confidence

The reader's orientation and reading mode configuration has been moved from the legacy settings sheet to a new Compose-based interface. This change introduces a new \ReaderOrientation\ enum to manage screen lock and rotation preferences (such as portrait, landscape, and free rotation) and updates the \ReadingMode\ enum to handle viewer selection (like left-to-right, right-to-left, and webtoon modes) with associated icons and logic. Users will experience this as a modernized, consistent settings UI for controlling how content is displayed and oriented within the reader.

app/src/main/java/eu/kanade/tachiyomi/ui/reader/setting · high confidence

The reader settings dialog has been rebuilt using Jetpack Compose, replacing the legacy Android preference system. This change introduces a tabbed interface with Reading Mode, General, and Color Filter sections, utilizing Material 3 components like FilterChips and SliderItems for a more modern and consistent user experience.

app/src/main/java/eu/kanade/presentation/reader/settings · high confidence

The reader viewer UI components have been refactored to use Jetpack Compose for rendering and interaction. The progress indicator and chapter transition view now use Compose, providing a consistent visual style and smoother updates. A new custom gesture detector handles long taps without conflicting with quick scale, and a specialized button class ensures tap events on navigation controls are processed correctly. Configuration for viewer settings is now managed via a centralized base class that observes preference changes, and the viewer interface has been standardized to handle key and motion events uniformly.

app/src/main/java/eu/kanade/tachiyomi/ui/reader/viewer · high confidence

The About settings screen has been rebuilt using Jetpack Compose, introducing a modern UI with a version display that copies debug info to the clipboard, an integrated update checker, and updated social links. A key behavioral change is the replacement of the previous open-source license display with the Material 3 version of the AboutLibraries library, which now presents a scrollable list of dependencies that users can tap to view individual license details in a dedicated screen.

app/src/main/java/eu/kanade/presentation/more/settings/screen/about · high confidence

The anime tracking interface has been updated with new UI components for searching and managing tracked anime. The search screen now uses a modern text field state for input, displays average scores in search results, and hides the keyboard when a result is selected. The info dialog provides a clearer view of tracking details, including support for private tracking indicators, copy-to-clipboard functionality for tracker URLs via long-press, and better handling of episode counts and dates.

app/src/main/java/eu/kanade/presentation/track/anime · high confidence

The extension management interface has been replaced with new screens for both manga and anime sources. Manga extension repos are now displayed in a list with options to open the website, copy the index URL, and delete the repo. Anime extension stores have a similar list view but include an additional button to open the store's Discord channel. Both screens feature a refresh button in the app bar and a floating action button to add new sources. The add dialog for manga repos now uses a URI keyboard type and validates that the repo name does not already exist, while the anime store add dialog supports processing states and error messages.

app/src/main/java/eu/kanade/presentation/more/settings/screen/browse/components · high confidence

The home screen now uses a Voyager-based TabNavigator with a static key to preserve tab state across configuration changes, ensuring users return to their last active tab. Navigation is adaptive: it displays a NavigationRail on tablet layouts and an animated NavigationBar on phones, with the bottom bar hiding when the 'More' tab is active. The screen also implements a BackHandler that intelligently returns to the user's configured start screen, and supports opening specific library items or extensions via deep links from notifications.

app/src/main/java/eu/kanade/tachiyomi/ui/home · high confidence

The manga entry and chapter list screens now use a new set of Compose components that provide a more consistent and interactive experience. The chapter list items now feature swipeable actions for quick management, a dedicated download indicator with progress tracking and context menus, and improved visual hierarchy for titles and metadata. The manga info header has been updated with a blurred backdrop cover image and a refined action row for library and tracking controls. Additionally, a new cover dialog allows users to view, share, save, and edit manga covers with zoom capabilities, and a scanlator filter dialog enables easy exclusion of specific scanlators from search results.

app/src/main/java/eu/kanade/presentation/entries/manga/components · high confidence

The manga tracking experience has been updated with new UI components. The tracker info dialog now displays average scores in search results, supports copying the tracker URL via long-press on the icon, and hides the keyboard when a search result is selected. The interface also uses modern Material 3 color roles and updated text field states for better consistency and accessibility.

app/src/main/java/eu/kanade/presentation/track/manga · high confidence

The app's base activity logic has been reorganized into two new delegate classes: SecureActivityDelegate and ThemingDelegate. SecureActivityDelegate now centralizes the app lock mechanism, handling screen security, authentication checks on resume, and managing the unlock state based on delay preferences. ThemingDelegate manages the application of visual themes, mapping specific theme identifiers (such as Lavender, Nord, Cotton Candy, and Mocha) to their corresponding Android style resources and supporting amoled variants.

app/src/main/java/eu/kanade/tachiyomi/ui/base/delegate · high confidence

The app now displays more granular relative timestamps for recent events, showing "Now" for immediate actions and specific hour/minute counts for items within the last day, while future dates are labeled as upcoming. This change is driven by new Kotlin extension functions in the \lang\ package that utilize the modern \java.time\ API for date calculations. Additionally, the update introduces utility extensions for handling \Closeable\ resources safely and inverting screen tapping regions (\RectF\) based on reader preferences.

app/src/main/java/eu/kanade/tachiyomi/util/lang · high confidence

The application has removed the legacy Dagger 1 dependency injection infrastructure, specifically deleting the \App\, \AppComponent\, and \AppModule\ classes. This cleanup eliminates the manual application component initialization and singleton binding logic that was previously handled in these files, indicating a migration away from the older DI framework.

app/src/main/java/eu/kanade/mangafeed · high confidence

The Browse and Stats tabs have been refactored to use animated vector icons that change state when selected, improving visual feedback. In the Browse tab, tapping the tab twice now opens the global search screen, and the tab layout has been restructured to include separate sections for anime and manga sources, extensions, and migration tools. The Stats tab similarly uses animated icons and organizes content into anime and manga statistics sections.

app/src/main/java/eu/kanade/tachiyomi/ui/browse · high confidence

The build system has been restructured to remove the deprecated \subprojects\ block in favor of explicit, reusable Gradle convention plugins located in \buildSrc\. New plugins such as \mihon.android.application\, \mihon.library\, and \mihon.benchmark\ now centrally configure Android settings, test setups, and Compose integration via shared build-logic helpers. Additionally, code formatting is standardized using Spotless with ktlint, which replaces the previous detekt-based linting approach.

buildSrc/src/main/kotlin · high confidence

The extension update notification now respects the user's privacy preferences. If the 'Hide notification content' setting is enabled, the notification will no longer display the names of the extensions being updated, showing only the count of updates instead. Additionally, the notification correctly opens the appropriate tab (Manga or Anime) based on the type of extensions being updated.

app/src/main/java/eu/kanade/tachiyomi/extension · high confidence

The backup system's data models have been completely rewritten to use Kotlinx Serialization with Protobuf encoding, replacing the previous format. This change introduces new model classes for manga, anime, chapters, episodes, categories, sources, tracking, and preferences, ensuring structured and efficient backup file creation and restoration.

app/src/main/java/eu/kanade/tachiyomi/data/backup/models · high confidence

The application's data migration logic has been completely rewritten to support versioned migrations. The new system introduces a \Migration\ interface with version numbers, allowing migrations to be sorted and executed in a specific order. It includes multiple strategies (\InitialMigrationStrategy\, \VersionRangeMigrationStrategy\, \NoopMigrationStrategy\) to handle different migration scenarios, such as first-time setup or upgrades between specific versions. The \Migrator\ object now orchestrates these migrations using a \MigrationJobFactory\ and \MigrationContext\, supporting dry-run modes and providing a listener for completion. This change aims to fix previous issues where migrations were not executing correctly and to prevent UI freezes during the process.

app/src/main/java/mihon/core/migration · high confidence

The app now uses distinct background workers for updating anime episodes and metadata, allowing these processes to run independently. The new AnimeLibraryUpdateJob handles episode list updates with support for seasonal anime and device restrictions, while AnimeMetadataUpdateJob manages metadata refreshes separately. This separation improves reliability and allows users to control update behaviors more granularly.

app/src/main/java/eu/kanade/tachiyomi/data/library/anime · high confidence

Library updates for manga are now split into two distinct background tasks: one for syncing chapters and another for refreshing metadata (such as cover images and details). This separation allows each process to run independently, improving reliability and ensuring that metadata refreshes are not blocked by chapter synchronization issues.

app/src/main/java/eu/kanade/tachiyomi/data/library/manga · high confidence

The Categories screen now features distinct tabs for managing anime and manga categories independently. This change introduces dedicated screen models and UI components for each content type, allowing users to create, rename, reorder, hide, and delete categories within their respective sections. The implementation respects the 'hide hidden categories' library preference for both anime and manga lists, ensuring that visibility settings are applied consistently across both new tabs.

app/src/main/java/eu/kanade/tachiyomi/ui/category · high confidence

The settings interface has been reorganized into distinct, dedicated screens for each category (Appearance, Browse, Data, Downloads, Library, and Advanced), replacing the previous monolithic layout. This change introduces a new \SearchableSettings\ interface to standardize how these screens are rendered and navigated, and adds a \Commons.kt\ utility to handle category label formatting for settings subtitles. Users will now experience a more modular and navigable settings menu where each section is its own screen.

app/src/main/java/eu/kanade/presentation/more/settings/screen · high confidence

The Settings and Player Settings screens have been rewritten to use the Voyager navigation library, replacing the previous implementation. This change introduces a two-panel layout for tablet UIs, allowing users to view the settings list and details simultaneously, while maintaining a standard single-panel navigation flow for phones. The migration also includes specific handling for back-press behavior and system window insets to ensure consistent navigation and layout across device types.

app/src/main/java/eu/kanade/tachiyomi/ui/setting · high confidence

The Shikimori tracker now automatically updates the status to 'Completed' when you finish the last chapter of a manga or the last episode of an anime. Previously, the status would remain 'Reading' or 'Watching' even after consuming all content; this change ensures your tracking list accurately reflects completion without manual intervention.

app/src/main/java/eu/kanade/tachiyomi/data/track/shikimori · high confidence

The Shikimori anime and manga tracking integration now uses dedicated data classes (SMEntry, SMUserListEntry, SMOAuth, etc.) to parse API responses. This change introduces structured deserialization for authentication tokens, user list entries, and search results, ensuring that fields like scores, status, and media counts are correctly mapped to the app's internal track models.

app/src/main/java/eu/kanade/tachiyomi/data/track/shikimori/dto · high confidence

The app now automatically selects the most appropriate extension installer based on your device environment. On MIUI devices, the legacy installer is used by default and the standard PackageInstaller option is hidden to avoid installation failures. If Shizuku is not installed, the app will not allow selecting the Shizuku installer, falling back to the default instead. This ensures a smoother extension installation experience without requiring manual configuration.

app/src/main/java/eu/kanade/domain/base · high confidence

The Downloads screen now uses a single tabbed interface to display both Anime and Manga download queues side-by-side, replacing the previous separate views. Users can switch between the two queues via tabs, with the top bar and floating action buttons dynamically updating to show the correct count and controls (pause/resume/stop) for the active queue.

app/src/main/java/eu/kanade/tachiyomi/ui/download · high confidence

The tracker authentication process has been consolidated into a single entry point. Instead of launching separate activities for each service, the app now uses a unified TrackLoginActivity that handles OAuth redirects for AniList, Bangumi, MyAnimeList, Shikimori, and Simkl. This activity displays a standard loading screen during the authentication handshake and automatically routes the user back to the main settings screen upon completion or failure.

app/src/main/java/eu/kanade/tachiyomi/ui/setting/track · high confidence

The app now uses a centralized ImageSaver component to handle saving manga pages and covers, introducing specific behavior for Android 10 (API 29) and above. On these devices, images are saved via the MediaStore API into the Pictures or Documents directory (depending on MIME type) with the app name as a subfolder, ensuring they appear in the system gallery. The implementation overwrites existing files with the same name in the same location rather than creating duplicates, sets the file's modification time to the current moment, and triggers a media scan to make the new image immediately visible to other apps.

app/src/main/java/eu/kanade/tachiyomi/data/saver · high confidence

The Updates tab now respects the 'Move Updates to More' navigation setting. When this setting is enabled, the Updates tab is moved to the 'More' section of the navigation bar, and selecting it again navigates the user to the Downloads tab. This change integrates the Updates screen into the new multiplatform string resource system and Voyager-based tab navigation.

app/src/main/java/eu/kanade/tachiyomi/ui/updates · high confidence

The image loading library has been upgraded from Coil 2.x to Coil 3. This change introduces new keyers for anime and manga covers to better handle custom cover and background images, and adds a custom image decoder to support additional formats like AVIF, JXL, and HEIF that are not natively supported by the system. The network fetchers now use Okio for file handling and explicitly prevent OkHttp from caching cover and chapter images to avoid conflicts with the app's own caching logic.

app/src/main/java/eu/kanade/tachiyomi/data/coil · high confidence

The WebView interface has been rewritten using Jetpack Compose and the Voyager navigation library, replacing the previous implementation. This change introduces a new screen model (WebViewScreenModel) to manage state and logic, such as fetching source headers and handling actions like sharing, opening in a browser, and clearing cookies. Users will experience a modernized UI for web content, with improved navigation handling and consistent behavior across manga and anime sources.

app/src/main/java/eu/kanade/tachiyomi/ui/webview · high confidence

The WebView screen now detects when a page is blocked by Cloudflare (by checking for specific script options or Ray IDs in the HTML) and displays a warning banner with a link to the troubleshooting guide. Additionally, the WebView client now prevents blob URLs from being opened as webpages and ignores intent:// URLs, improving security and navigation stability.

app/src/main/java/eu/kanade/presentation/webview · high confidence

The Webtoon viewer has been completely rewritten to use a custom RecyclerView-based layout (WebtoonRecyclerView) with a dedicated layout manager (WebtoonLayoutManager) for improved scrolling and preloading. The new implementation introduces a WebtoonAdapter to manage page and chapter transition items, WebtoonPageHolder for individual page rendering, and WebtoonTransitionHolder for chapter navigation. Touch handling is now managed by WebtoonFrame, which delegates gestures to the recycler view, enabling features like double-tap zoom, zoom-out disabling, and side padding. Configuration is handled by WebtoonConfig, which binds reader preferences for navigation modes, image cropping, and split settings. This change replaces the previous viewer implementation with a more modular and performant structure.

app/src/main/java/eu/kanade/tachiyomi/ui/reader/viewer/webtoon · high confidence

This change introduces new interactor classes to resolve issues with EnhancedTracker services not auto-binding when adding manga to the library and to improve how chapter progress is synced. AddMangaTracks now handles binding for enhanced trackers and ensures local read progress updates the remote last chapter read if it is higher. SyncChapterProgressWithTrack specifically targets EnhancedMangaTracker instances to update remote last chapter read based on local continuous reading and mark chapters as read. TrackChapter improves reliability by using a delayed update job when tracking fails, preventing spam on errors. RefreshMangaTracks allows fetching updated tracking data from all logged-in trackers.

app/src/main/java/eu/kanade/domain/track/manga/interactor · high confidence

Added DummyTracker test fixture for tracker integration testing; Updated migration tests and removed legacy data manager tests.

This change introduces the foundational Gradle build configuration for the application, establishing the project's module structure (app, core, data, domain, presentation) and defining the initial set of dependencies via version catalogs. It sets up the build environment with specific versions for key libraries such as SQLDelight 2.0.2, OkHttp 5.4.0, Coil 3.1.0, and Voyager 2.2.21, while configuring build features like ViewBinding and ProGuard for release builds.

(dependencies) · high confidence

The project's dependency management has been restructured to use Gradle Version Catalogs, consolidating version definitions into new TOML files (androidx.versions.toml, compose.versions.toml, kotlinx.versions.toml, aniyomi.versions.toml) and introducing a new gradle-daemon-jvm.properties file to specify Java 17 as the toolchain. This change accompanies a major upgrade of the Kotlin language and tooling to version 2.4.0, along with significant updates to the Android Gradle Plugin (8.9.1), Compose BOM (2025.10.01), and various AndroidX libraries.

gradle · high confidence

The project's Gradle wrapper has been updated from version 2.2.1 to 8.13. This significant version jump ensures that builds use the modern Gradle distribution, which includes improved performance, new features, and better compatibility with current Android development tools. The configuration file also introduces explicit network timeout and distribution URL validation settings to enhance build reliability.

gradle/wrapper · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 44 → 49 (+4.7)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 84 → 84 (-0.2)
• Architecture 94 → 89 (-5.4)
• Maturity 44 → 52 (+7.4)
• Readiness 32 → 40 (+7.4)
• Security 42 → 43 (+1.7)
• Domain Modelling 100 → 100 (+0.0)

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• Duplicated block (10 lines × 2) (app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsLibraryScreen.kt)
• Duplicated block (10 lines × 2) (app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsLibraryScreen.kt)
• Duplicated block (10 lines × 2) (app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt)
• Duplicated block (10 lines × 2) (presentation-core/src/main/java/tachiyomi/presentation/core/components/VerticalFastScroller.kt)
• Duplicated block (11 lines × 2) (app/src/main/java/eu/kanade/presentation/entries/anime/AnimeScreen.kt)
• Duplicated block (11 lines × 2) (app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsReaderScreen.kt)
• Duplicated block (11 lines × 2) (app/src/main/java/eu/kanade/presentation/more/settings/screen/player/PlayerSettingsAudioScreen.kt)
• Duplicated block (11 lines × 2) (app/src/main/java/eu/kanade/presentation/more/settings/screen/player/PlayerSettingsSubtitleScreen.kt)
• Duplicated block (11 lines × 2) (app/src/main/java/eu/kanade/tachiyomi/data/notification/NotificationReceiver.kt)
• Duplicated block (11 lines × 2) (app/src/main/java/eu/kanade/tachiyomi/data/notification/NotificationReceiver.kt)
• Duplicated block (11 lines × 3) (app/src/main/java/aniyomi/util/DataSaver.kt)
• Duplicated block (11 lines × 3) (app/src/main/java/eu/kanade/presentation/more/settings/PreferenceItem.kt)
• Duplicated block (12 lines × 2) (app/src/main/java/eu/kanade/tachiyomi/data/track/myanimelist/MyAnimeListApi.kt)
• Duplicated block (12 lines × 2) (app/src/main/java/eu/kanade/tachiyomi/data/track/shikimori/ShikimoriApi.kt)
• Duplicated block (12 lines × 2) (app/src/main/java/eu/kanade/tachiyomi/data/track/shikimori/ShikimoriApi.kt)
• Duplicated block (12 lines × 2) (app/src/main/java/eu/kanade/tachiyomi/di/AppModule.kt)
• Duplicated block (12 lines × 2) (app/src/main/java/eu/kanade/tachiyomi/ui/download/DownloadsTab.kt)
• Duplicated block (12 lines × 2) (app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/PlayerControls.kt)
• …and 70 more

• AnimeDownloader.getOrDownloadVideoFile (cognitive 20) (app/src/main/java/eu/kanade/tachiyomi/data/download/anime/AnimeDownloader.kt)
• AnimeExtensionLoader.loadExtension (cognitive 22) (app/src/main/java/eu/kanade/tachiyomi/extension/anime/util/AnimeExtensionLoader.kt)
• AnimeExtensionLoader.loadExtension (cyclomatic 21) (app/src/main/java/eu/kanade/tachiyomi/extension/anime/util/AnimeExtensionLoader.kt)
• AnimeExtensionsScreenKt.AnimeExtensionContent (cyclomatic 19) (app/src/main/java/eu/kanade/presentation/browse/anime/AnimeExtensionsScreen.kt)
• AnimeInfoHeaderKt.AnimeContentInfo (cyclomatic 22) (app/src/main/java/eu/kanade/presentation/entries/anime/components/AnimeInfoHeader.kt)
• AnimeLibraryScreenModel.applySort (cognitive 23) (app/src/main/java/eu/kanade/tachiyomi/ui/library/anime/AnimeLibraryScreenModel.kt)
• AnimeLibraryScreenModel.applySort (cyclomatic 26) (app/src/main/java/eu/kanade/tachiyomi/ui/library/anime/AnimeLibraryScreenModel.kt)
• AnimeLibraryTab.Content (cyclomatic 18) (app/src/main/java/eu/kanade/tachiyomi/ui/library/anime/AnimeLibraryTab.kt)
• AnimeLibraryUpdateJob.addAnimeToQueue (cognitive 16) (app/src/main/java/eu/kanade/tachiyomi/data/library/anime/AnimeLibraryUpdateJob.kt)
• AnimeLibraryUpdateJob.addAnimeToQueue (cyclomatic 18) (app/src/main/java/eu/kanade/tachiyomi/data/library/anime/AnimeLibraryUpdateJob.kt)
• AnimeScreen.Content (cognitive 27) (app/src/main/java/eu/kanade/tachiyomi/ui/entries/anime/AnimeScreen.kt)
• AnimeScreen.Content (cyclomatic 32) (app/src/main/java/eu/kanade/tachiyomi/ui/entries/anime/AnimeScreen.kt)
• AnimeScreenKt.AnimeScreenLargeImpl (cognitive 16) (app/src/main/java/eu/kanade/presentation/entries/anime/AnimeScreen.kt)
• AnimeScreenKt.AnimeScreenSmallImpl (cognitive 19) (app/src/main/java/eu/kanade/presentation/entries/anime/AnimeScreen.kt)
• AnimeScreenKt.AnimeScreenSmallImpl (cyclomatic 18) (app/src/main/java/eu/kanade/presentation/entries/anime/AnimeScreen.kt)
• AnimeScreenModel.toggleFavorite (cognitive 23) (app/src/main/java/eu/kanade/tachiyomi/ui/entries/anime/AnimeScreenModel.kt)
• AnimeScreenModel.toggleSelection (cognitive 31) (app/src/main/java/eu/kanade/tachiyomi/ui/entries/anime/AnimeScreenModel.kt)
• AnimeScreenModel.toggleSelection (cyclomatic 19) (app/src/main/java/eu/kanade/tachiyomi/ui/entries/anime/AnimeScreenModel.kt)
• AnimeUpdatesScreenModel.toggleSelection (cognitive 28) (app/src/main/java/eu/kanade/tachiyomi/ui/updates/anime/AnimeUpdatesScreenModel.kt)
• AnimeUpdatesScreenModel.toggleSelection (cyclomatic 16) (app/src/main/java/eu/kanade/tachiyomi/ui/updates/anime/AnimeUpdatesScreenModel.kt)
• …and 712 more

• 9 commits — 6 feature/other, 3 fixes

• app/src — 4 commits
• .github/ISSUE_TEMPLATE — 2 commits
• source-api/src — 2 commits
• gradle/aniyomi.versions.toml — 1 commit

• fix: Ext lib 17 fixes pt. 2 (#2380)
• fix: fix(torrentutils): Fix npe when adding as magnet (#2386)
• fix: fix: Extensions lib 17 related fixes (#2374)
• change: Bump torrserver (#2383)
• change: chore: Release Aniyomi v0.18.2.0
• change: feat: Add memo to Hoster and Video (#2379)
• change: feat: Add related entries support (#2378)
• change: feat: Add support for extensions-lib v17
• change: feat: Replace extension repo with extension store and implement new format (#2375)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

aniyomiorg/aniyomi was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.