komikku-app/komikku

Komikku is an Android application for browsing, downloading, and reading manga and comics from various online sources and trackers. It features a modern Jetpack Compose interface with extensive customization options, including dynamic theming and panorama cover displays. The system supports cross-device synchronization via WebDAV and Google Drive, integrates with multiple tracking services like AniList and MyAnimeList, and manages a local library with advanced filtering, merging, and backup capabilities.

71 changes.

The project underwent a comprehensive architectural overhaul, migrating the codebase from legacy Java and Dagger 1 to Kotlin, Jetpack Compose, and modern dependency injection. This period saw the complete rewrite of core modules, including the reader, download manager, and UI navigation, while significantly expanding supported sources and tracking integrations.

93 changes.

The project underwent a comprehensive migration of its user interface to Jetpack Compose, rewriting major screens such as the library, reader, settings, and browse tabs while introducing modern Material 3 styling and tablet support. Concurrently, the codebase was restructured into a clean domain-layer architecture with dedicated interactors and modules, replacing legacy preference systems and XML-based layouts. This period also saw significant backend improvements, including OAuth authentication for MangaDex, new tracking integrations for Komga and Kavita, and expanded source API capabilities via Kotlin Multiplatform.

62 changes.

This period focused on migrating the application's UI to Jetpack Compose, introducing a new presentation-core module, and modernizing core components like the reader, library, and settings. It also expanded functionality with new features such as WebDAV sync, Discord Rich Presence, encrypted database support, and a structured onboarding flow, while significantly improving backup, restore, and migration reliability.

6 changes.

This period focused on a comprehensive redesign of the migration workflow, introducing advanced configuration screens, smart search capabilities, and improved data preservation for manga and tracker entries. It also enhanced source management by allowing users to enable or disable extension stores and implemented throttling mechanisms to stabilize remote updates for specific sources.

The 8Muses source is now available, implemented as a delegated source that integrates with the new MetadataSource and UrlImportableSource interfaces. This allows users to import comics via URL and view metadata (such as artist and tags) directly in the UI without relying on the site's description field. Users are advised to manually migrate existing comics to the extension, as the old format is no longer supported.

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

The app now includes Kotlin-based Compose ImageVector definitions for the Eh and MangaDex logos, replacing or supplementing previous asset handling. These new files define the logos as scalable vector graphics within the \exh.assets\ package, allowing them to be used directly in Compose UI components without relying on static image resources.

app/src/main/java/exh/assets · high confidence

Users can now enable Discord Rich Presence to display their current reading activity on Discord. This change introduces a new settings screen for managing Discord credentials and configuring presence details, including options to show progress, timestamps, buttons, and custom messages, as well as incognito mode to hide activity for specific categories.

app/src/main/java/eu/kanade/domain/connections, app/src/main/java/eu/kanade/presentation/connection, app/src/main/java/eu/kanade/tachiyomi/ui/setting/connections · high confidence

Users can now sync their reading progress with the Kavita library server. This change introduces the Kavita tracker implementation, including API client, authentication handling via JWT tokens, and status mapping (Unread, Reading, Completed), allowing automatic tracking of series read status and chapter counts.

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 sync their reading progress with a Komga server. This change introduces the Komga tracker integration, allowing the app to automatically update read status and chapter progress on the server, as well as match and refresh series information.

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

The Extension Stores settings screen now supports enabling and disabling individual extension stores without deleting them. Users can toggle a store's active status via a new visibility button in the list, with disabled stores visually indicated by reduced opacity and strikethrough text. This change introduces the necessary UI components, screen model logic for managing disabled store URLs, and state persistence to allow users to temporarily disable sources while keeping their configuration intact.

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

Users can now define specific time ranges during which biometric authentication is required to access the app. This new feature introduces a dedicated screen for managing these lock periods, allowing users to create and delete time ranges via a material time picker. The system prevents overlapping or conflicting time ranges to ensure consistent security behavior.

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

A new CrashScreen component has been introduced to handle application crashes. When a crash occurs, users are presented with an interface displaying the exception details and offering two actions: dumping crash logs for debugging purposes or restarting the application. This screen utilizes the shared InfoScreen layout and integrates with the existing CrashLogUtil to facilitate log collection.

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

A new Stats screen has been introduced to display detailed usage statistics and library metrics. The screen presents data in four sections: an Overview showing library manga count, total read duration, and completed titles; Titles stats for global update items, started, and local manga; Chapters stats covering total, read, and downloaded chapter counts; and Tracker stats displaying tracked title count, mean score, and number of used trackers.

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

Users can now export a minimal subset of their library data to a CSV file. This new capability, implemented in the LibraryExporter component, allows exporting favorite manga entries with configurable columns for title, author, and artist, providing a lightweight alternative to full library backups.

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

The Stats screen now allows users to toggle whether statistics include manga that have been fully read. A new overflow menu action in the app bar lets users switch between showing stats for library entries only or including all read entries, providing a more comprehensive view of reading history.

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

Users can now filter the list of available sources during the migration process by typing a search query. This change introduces a search input that filters sources by name, installed extension name, or source ID in real-time, allowing for quicker navigation when selecting a source to migrate from.

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

The MangaDex handler now integrates with several external manga sources, allowing users to read chapters from Azuki, Bilibili, Comikey, MangaHot, and Namicomi directly within the MangaDex interface. New handler classes (AzukiHandler, BilibiliHandler, ComikeyHandler, MangaHotHandler, NamicomiHandler) and corresponding DTOs have been added to fetch and parse page lists from these services, extending the existing MangaDex delegation features to include content from these third-party providers.

app/src/main/java/exh/md/handlers · high confidence

A new Gradle task named 'generateLocalesConfig' has been introduced in the build logic to automatically generate the Android 'locales\_config.xml' resource file. This task scans the 'moko-resources' directory for string resources, extracts the supported locale names, and writes the corresponding XML configuration to the output resource directory, ensuring the app correctly declares its supported locales.

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

A new dialog component has been introduced to allow users to input and save custom Igneous cookies. This UI element presents a text field for the cookie value and uses localized strings for the title, message, and action buttons (OK/Cancel), ensuring the feature is accessible in the app's supported languages.

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

A new \DelayedTrackingStore\ has been introduced to manage a queue of tracking updates. This component stores pending tracking data (specifically track IDs and last chapter read values) in private shared preferences, allowing the application to batch or defer tracking synchronization rather than updating immediately. This supports the 'Refresh tracks before updating progress' logic by ensuring tracking state is managed asynchronously.

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

The macrobenchmark module now includes the necessary components to measure app startup performance and generate baseline profiles. This adds a \BaselineProfileGenerator\ test that simulates a critical user path (launching the app, navigating to Updates, History, and Settings) to create AOT compilation rules, and a suite of startup benchmarks (\ColdStartupBenchmark\, \WarmStartupBenchmark\, \HotStartupBenchmark\) that measure startup times under various compilation modes (None, Partial with/without baseline profile, Full). These changes enable developers to verify and optimize app launch speed using Android's macrobenchmarking tools.

macrobenchmark · high confidence

A new SmartLibrarySearchEngine has been introduced to enable smart searching within the user's library. This component allows users to search for manga titles using a fuzzy matching approach, filtering library items by their original title against a provided query string.

app/src/main/java/exh/smartsearch · high confidence

A new TrackLogoIcon composable has been introduced to display tracker logos with rounded corners and a fixed size, supporting both click and long-press interactions. This component is accompanied by a preview provider to enable visual inspection in Android Studio, improving developer experience for UI updates related to tracking services.

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

The design system now includes utility functions to detect screen width breakpoints, enabling UI components to adapt to different device sizes. Specifically, \isMediumWidthWindow()\ and \isExpandedWidthWindow()\ allow the application to determine if the current window width exceeds 600dp or 840dp respectively, facilitating responsive layout adjustments for tablets and larger screens.

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

The app now automatically manages E-Hentai and ExHentai user configurations by creating and applying a dedicated app profile on the server. This includes detecting and applying purchased Hath perks (such as thumbnail count and paging enlargement) and persisting session cookies to maintain login state. Users benefit from consistent display settings (image quality, title language, category filters) and improved reliability when browsing these sources, as the app handles the profile lifecycle rather than relying on manual setup.

app/src/main/java/exh/uconfig · high confidence

Added support for the Bangumi tracking service, allowing users to sync their reading progress, scores, and status with the Bangumi platform. This includes full authentication via OAuth, automatic status updates based on chapter reading, and search functionality for manga titles.

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

Users can now perform batch searches for recommendations across their library, with results sorted by relevance. This update introduces a new search interface that allows filtering results to include or exclude sources and trackers, as well as hiding entries already present in the library. A progress dialog provides real-time feedback during the search process, including initialization, processing, and error states, while background locks ensure the device remains active during the operation.

app/src/main/java/exh/recs/batch · high confidence

The migration search interface now supports bulk favorite operations. Users can enter a selection mode in both the global migration search and the per-source migration search to select multiple manga at once, rather than migrating or favoriting them individually. This includes a toolbar for managing selections (select all, reverse, clear) and integrated dialogs for bulk actions, allowing for faster management of favorite lists during the migration process.

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

The Category screen now supports hiding individual categories. This change introduces a new \HideCategory\ domain interactor and a corresponding \hideCategory\ function in the screen model, wired up to a new \onClickHide\ callback in the UI. When a user triggers this action, the category is hidden via the domain layer, and any resulting errors are displayed as toast notifications.

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

Users can now customize the app's theme color via a new color picker screen that applies the selected color immediately. Additionally, the app language selection screen now displays flags next to each language option to help identify them visually.

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

The Debug Info screen in settings has been expanded to provide deeper diagnostic data. Users can now view the status of background worker tasks (enqueued, running, and finished), including specific details like next scheduled run times and attempt counts, and can copy this information to the clipboard. Additionally, a new option allows users to view and copy the Protobuf schema definition used for backup files, aiding in compatibility troubleshooting.

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

The app now supports Discord Rich Presence, allowing your current activity (such as browsing the library or reading a manga) to be displayed on your Discord profile. This feature introduces a new connection service architecture in the \data/connections\ package, with a dedicated Discord implementation that manages account tokens, handles multiple Discord accounts, and runs a foreground service to maintain the WebSocket connection. Users can enable this via settings, and the app will display a notification to manage the service.

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

The domain module has been reorganized to include new models and interactors for managing extension stores (Add, Get, Remove, Update), alongside a comprehensive set of category management interactors (Create, Delete, Hide, Rename, Reorder, SetSortMode) and chapter filtering logic. This change introduces hidden categories, merged source chapter deduplication, and specific preferences for E-Hentai/ExHentai sources, while also adding an Upcoming manga interactor to support the new Upcoming screen feature.

domain · high confidence

The Browse Source screen now supports tag autocomplete in filter fields, allowing users to quickly add tags via a dropdown and manage them with removable chips. Users can save, load, and delete custom search filters as saved searches, which are displayed as selectable chips in the filter dialog. Additionally, an incognito mode toggle is available per source, enabling browsing without affecting library state. These changes are implemented in the BrowseSourceScreen, its model, and associated UI components like the filter dialog and autocomplete input.

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

The backup creation process in the app module now supports including global popular/latest feeds and saved searches in addition to library entries, categories, and settings. Users can also choose to include private preferences when backing up app and source settings. These new options are exposed through the backup configuration UI, allowing for more granular control over what data is included in manual and automatic backups.

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

The app now includes several new built-in color schemes (Catppuccin, Nord, Monochrome, Cloudflare, Cottoncandy, Doom, Matrix, Mocha, and Sapphire) alongside the existing defaults. It also supports dynamic theming via Material Expressive, allowing users to generate color palettes from a seed color or system-wide dynamic colors (Monet), and introduces a new Custom theme option that lets users define their own seed color and style.

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

The Browse \> Feed tab has been rewritten in Compose to allow users to reorder their feed sources via drag-and-drop and perform bulk favorite operations. A new 'Sort Feed' action in the top bar opens a dedicated screen for reordering, while a bulk-selection mode enables toggling favorites for multiple manga at once, with the bottom navigation bar hiding during selection to maximize screen space.

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

The Global Search screen now allows users to long-press items to enter a bulk-selection mode for favoriting multiple manga at once, rather than navigating to individual details. Additionally, the search interface includes a filter to toggle between showing results from all sources or only pinned sources, with the pinned source chip automatically hidden if no sources are pinned.

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

The history screen now supports filtering entries by unfinished manga, unfinished chapters, and non-library items via a new settings dialog. Individual history items display indicators for unread chapters and allow users to favorite manga directly from the list. The layout also includes support for panoramic cover images and improved visual feedback for selection and long-press actions.

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

Adds a new MDList tracker implementation that allows users to track manga via MangaDex, supporting status updates (such as Reading, Completed, Plan to Read) and rating synchronization. The integration handles authentication via MangaDex tokens, fetches manga metadata, and manages follow statuses, enabling users to keep their local library in sync with their MangaDex list.

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

Added a set of Kotlin data classes (DTOs) in the MyAnimeList tracking module to strictly parse API responses from MyAnimeList. These classes cover user data, OAuth token handling (including expiration logic), manga search results, and list status updates, enabling the app to reliably deserialize JSON payloads from the MyAnimeList API.

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

A new Page Preview screen has been added, allowing users to view a grid of page thumbnails for a specific chapter before opening it. This feature is implemented using the Voyager navigation library and includes a screen model that fetches manga metadata, chapter information, and page preview images. Users can navigate between pages within the preview and tap a thumbnail to open the full reader at that specific page.

app/src/main/java/exh/pagepreview · high confidence

A new Page Preview screen has been added, allowing users to view a grid of page thumbnails for a manga. The screen includes a top app bar and a dialog that lets users jump to a specific page using a slider, with the selected page number displayed and confirmed via an 'OK' button.

app/src/main/java/exh/pagepreview/components · high confidence

A new data class, ReaderChapterItem, has been added to the reader chapter UI module to structure chapter list items. This model combines Chapter and Manga domain entities along with display flags (isCurrent) and formatting configuration (dateFormat), providing the necessary data structure for rendering chapter entries in the reader interface.

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

A new Upcoming screen has been added to the app, allowing users to view manga scheduled for future updates. This feature includes a Smart Update toggle (controlled by the MANGA\_OUTSIDE\_RELEASE\_PERIOD preference) that lets users filter the list to show only entries targeted for the next automatic update, with the toolbar title changing to "To be updated" when this filter is active. The implementation also introduces dedicated loading states for both the standard upcoming list and the Smart Update filtered list to improve perceived performance during data retrieval.

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

This change adds the UI components for the new Upcoming screen, including a calendar view that displays monthly events with day-specific counts and indicators, and a list item component for upcoming manga titles that features cover art with dominant color theming.

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

The app now includes a new automatic update mechanism for E-Hentai and ExHentai galleries, implemented via a WorkManager-based background worker (EHentaiUpdateWorker) that handles periodic checks, chapter fetching, and history synchronization. This system introduces a new notification service (EHentaiUpdateNotifier) to display real-time progress and error logs for updates, and a helper class (EHentaiUpdateHelper) to manage complex multi-version gallery merging, history deduplication, and category syncing. Additionally, a new EHTags object provides a centralized, structured list of E-Hentai tags for filtering and search, replacing previous ad-hoc tag handling.

app/src/main/java/exh/eh · high confidence

The application now supports encrypting the local database via a new security preference, which switches the database driver to SQLCipher and renames the database file when encryption is enabled. Additionally, new dependency injection modules have been introduced to manage preferences for EHentai-specific settings (SYPreferenceModule) and connection management (ConnectionsPreferences), alongside standard modules for history and sync preferences.

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

The tracking system now supports marking entries as private, allowing users to hide specific tracking records from public view on supported services. This is enabled by the addition of a \private\ field to the core \Track\ domain model and its database representation, along with helper functions to copy personal data and convert between domain and database models. Additionally, a new \AutoTrackState\ enum has been introduced to define user preferences for automatic tracking behavior (Always, Ask, Never), providing a structured way to control when tracking updates are triggered.

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

Users can now authenticate with MangaDex directly within the app via an OAuth flow. A new login activity handles the authorization callback, exchanging the code for a session and logging in, while also supporting logout functionality when no code is present.

app/src/main/java/exh/md · high confidence

The MangaDex extension has been updated to support rating manga, tracking reading status, and viewing similar manga. Users can now rate manga, mark chapters as read or unread, and view similar manga recommendations. The extension also respects user preferences for blocked groups and uploaders when fetching manga feeds.

app/src/main/java/exh/md/service · high confidence

Users can now add multiple E-Hentai galleries at once via a new dedicated screen. This feature allows pasting a list of URLs (supporting both e-hentai.org and exhentai.org formats) into a text field, which are then processed in the background with a visible progress indicator and a summary of successes and failures upon completion.

app/src/main/java/exh/ui/batchadd · high confidence

Added two new Kotlin files in the core preference module to bridge the existing preference system with Jetpack Compose. CheckboxState.kt introduces an extension function to convert TriState preferences into Compose ToggleableState, enabling direct use in UI components. PreferenceMutableState.kt provides a MutableState implementation that automatically syncs with preference changes via coroutine scopes, allowing preferences to be observed reactively in Compose screens.

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

The tracking interface now uses new Compose-based components (TrackInfoDialog, TrackItem) to display and manage tracker information, replacing previous implementations with a modern UI stack.

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

A new screen has been added to manage library update errors, allowing users to view, select, and manually delete specific errors. The interface includes multi-selection capabilities, options to select or invert all items, and actions to migrate or delete selected errors. It also features navigation helpers like scrolling to top/bottom or between error groups, providing a dedicated place to resolve persistent update issues.

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

The search functionality in the app has been replaced with a new engine that constructs SQL queries against local metadata tables. This change introduces support for namespace-based filtering (using the colon syntax, e.g., 'artist:'), tag aliases (such as 'c' for character), and wildcard characters ('?' for single, '\*' for multi). The implementation includes new classes for parsing query components and building SQL statements, enabling more precise and flexible searching within the library.

app/src/main/java/exh/search · high confidence

The genre settings screen now includes dedicated Compose components (SortTagContent and SortTagListItem) to display and manage a list of sort tags. Users can view tags in a scrollable list, reorder them using up/down buttons, and delete individual tags. The list items use stable keys to ensure smooth animations and consistent state during reordering.

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

The app now includes a new Updates Grid widget available for both the Android home screen and the Galaxy Z Flip cover screen. This widget displays a grid of recent chapter updates with cover art, allowing users to quickly see their latest reads. It respects the app's lock settings by showing a locked state when authentication is required, and it uses the system's dynamic colors on Android 12+ for a consistent look.

presentation-widget · high confidence

The app introduces a new Webtoon viewer implementation, replacing the previous version with a custom RecyclerView-based architecture. This new viewer supports continuous vertical reading, pinch-to-zoom, double-tap zoom, and configurable side padding. It also includes features like chapter transitions, download progress indicators, and error handling for failed pages. The viewer is designed to handle large images efficiently and provides a smoother reading experience for webtoon-style content.

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

The app introduces several new built-in themes (Catppuccin, Cloudflare, Cottoncandy, Doom, Green Apple, Lavender, Matrix, Midnight Dusk, Mocha, Monochrome, Nord, Sapphire, and Strawberry) alongside a refactored theming engine. This engine now supports true Amoled black backgrounds for dark mode, allowing users to save battery on OLED screens by using pure black for backgrounds and surfaces. Custom themes are also enhanced to use the MaterialKolor library for better dynamic color generation.

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

The browse source screens now use a new set of Compose-based components that support bulk selection (with visual highlighting of selected items), a new 'Comfortable Grid Panorama' display mode for wider cover images, and end-of-cover badges that display MangaDex follow status/relation or ranked search metadata. Source list items also show the extension name alongside the source name and include an NSFW indicator for adult sources.

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

This change introduces several new built-in sources to the application, including EHentai, NHentai, MangaDex, Pururin, and Lanraragi, alongside a new MergedSource that allows combining entries from multiple sources. The new sources provide features like URL importing, metadata parsing, and page previews, while the MergedSource enables users to view and manage content from different sources as a single entry.

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

The Browse screen now supports bulk-favoriting multiple manga at once, with a dedicated BulkFavoriteScreenModel handling selection, duplicate detection, and category assignment. The Browse tab layout is now configurable via preferences to hide the Feed tab or reorder tabs (Feed, Sources, Extensions, Migration). Additionally, double-tapping the Browse tab opens global search, and Discord RPC integration is added to show the current screen.

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

The app introduces dedicated cache management classes (ChapterCache, CoverCache, and PagePreviewCache) to handle storage of chapter page lists, manga cover images, and page previews respectively. These classes manage disk caching using MD5-hashed file names and integrate with user preferences for cache size limits, ensuring that cached data is properly stored, retrieved, and cleaned up to optimize storage usage and improve reading performance.

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

Added CollectionUtils.kt, introducing helper functions for list manipulation such as insertSeparators, fastFilterNot, fastPartition, and fastCountNot, along with a HashSet utility. Also added SourceUtil.kt, which provides a composable function to check if sources are loaded via the SourceManager.

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

A new core-metadata module has been introduced to centralize metadata handling, providing the foundational classes for serializing and deserializing ComicInfo.xml files and local MangaDetails. This includes the ComicInfo data structure with support for series, writer, artist, genre, tags, categories, and publishing status, along with conversion functions to map these fields to and from the internal SManga model. The module also defines the MangaDetails class for local series metadata, enabling automatic conversion between details.json and ComicInfo.xml formats for local sources.

core-metadata · high confidence

The application introduces a new core/common module that consolidates foundational infrastructure. This includes a comprehensive network layer with OkHttp integration, featuring a Cloudflare bypass mechanism via WebView, support for 12 DNS-over-HTTPS providers, and configurable rate limiting. Security is enhanced with new preferences for biometric app locks, database encryption (AES-256/AES-128), and the ability to opt out of analytics and Crashlytics. Additionally, the module provides utility classes for JavaScript evaluation, string manipulation, and file hashing, establishing the base for extension and core functionality.

core/common · high confidence

The app now includes a new CrashLogUtil that generates a detailed debug report (including app version, device info, WebView version, and problematic extension status) and directly shares it via the system share sheet, replacing the previous notification-based approach. Additionally, new utility functions for Manga covers allow local covers to be updated and custom covers for favorite manga to be cached, with the cache being cleared when covers are removed.

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

The data module now provides the concrete database and network implementations for managing extension stores (including legacy and new formats with gzip support), categories (with hidden status support), chapters (with sanitization and merge support), and history (with batch reset and filtering). This includes the AndroidDatabaseHandler for SQLDelight transactions, mappers for domain models, and repository implementations that persist and retrieve this data.

data · high confidence

A new debug interface has been added to the application, providing a centralized location for troubleshooting and configuration. The menu exposes a list of runtime functions (such as forcing migrations, resetting E-Hentai age flags, and managing background update jobs) that can be executed on demand, alongside a set of boolean toggles (like hiding cover images to show only colors or restricting update frequencies) that modify application behavior at runtime.

app/src/main/java/exh/debug · high confidence

A new UnlockActivity has been introduced to handle app unlocking via biometric authentication. This activity presents a biometric prompt using the app's name and, upon successful authentication, triggers the SecureActivityDelegate to unlock the application before finishing the activity.

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

This change introduces a suite of new domain-layer interactors in the manga module to handle specific library and data operations. Users gain the ability to manage library sort tags (create, delete, reorder, and retrieve) via dedicated interactors, and can now exclude specific scanlators from updates through new query and set operations. The update logic is refined with new interactors for updating manga metadata (fetch interval, last update time, cover modification date, and favorite status) and for setting reader viewer flags (reading mode and orientation). Additionally, a new interactor provides page preview support for specific sources, and a complex merge logic interactor handles combining multiple library entries into a single merged source entry.

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

The application introduces new domain model files to handle specific data structures. Manga.kt adds extension properties and helper functions to the Manga model, including logic to filter chapters based on download status, convert Manga instances to source models (SManga) while preserving original metadata, and generate ComicInfo metadata for archives. It also introduces support for encrypted CBZ archives via CbzCrypto padding. Additionally, a new PagePreview model is added to represent page preview data with image URLs and progress tracking, facilitating the display of previews for sources like ExHentai and NHentai.

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

A new DeleteDownload interactor has been added to the download domain module. This component provides a method to delete specific chapters from the download manager, ensuring the operation runs within a non-cancellable context and verifying the source exists before proceeding.

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

The library update error screen now uses a new \LibraryUpdateErrorUiItem\ component that displays individual error entries with their manga cover and source name. Users can now swipe an error item to delete it, and long-pressing an item triggers haptic feedback before entering selection mode. The list also features sticky headers that group errors by message type.

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

The app now includes a new Favorites Sync feature for E-Hentai and ExHentai sources, implemented in the new \FavoritesSyncHelper\ and \LocalFavoritesStorage\ classes. This feature allows users to synchronize their library favorites with the remote server, handling category mapping, conflict resolution, and throttling to prevent network bans. It introduces a new status system to track sync progress and errors, and ensures data consistency by validating library state and managing database snapshots during the sync process.

app/src/main/java/exh/favorites · high confidence

Added FileExtensions.kt and OkioExtensions.kt to the storage utilities, introducing helpers for sharing images via FileProvider, copying files while enforcing read-only permissions, and safely saving buffered sources to disk or streams with automatic directory creation and cleanup on failure.

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

This change introduces three new Kotlin extension files in the language utility package to support core app functionality. CloseableExtensions.kt provides a safe resource-closing utility for arrays of Closeable objects, ensuring proper cleanup even when exceptions occur. DateExtensions.kt adds modern Java.time-based helpers for converting timestamps, handling time zones, and generating relative date strings (e.g., "Today", "X days ago") using the new multiplatform string resources. RectFExtensions.kt adds a method to invert touch regions based on reader tapping settings, supporting the viewer navigation and reading experience.

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

The app now includes a dedicated InterceptActivity that handles incoming links (via Intent.ACTION\_VIEW). When a user opens a link, the app waits for sources to initialize, then uses a GalleryAdder to identify the correct source and add the entry. If multiple sources match, a dialog allows the user to choose. Upon successful addition, the app navigates to the Reader (if a chapter link) or the main screen (if a manga link); errors are displayed in a dialog.

app/src/main/java/exh/ui/intercept · high confidence

This change introduces several new UI components in the manga detail area: a dedicated screen for viewing related manga suggestions (RelatedMangasScreen), a screen for editing manga notes (MangaNotesScreen), a dialog for editing manga metadata (EditMangaDialog), a screen for managing custom covers (MangaCoverScreenModel), and a color palette preview screen (PaletteScreen). These additions provide users with new ways to interact with manga metadata, track related titles, and customize visual themes.

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

The migration flow now includes a dedicated configuration screen (MigrationConfigScreen) that allows users to select and reorder sources before starting a migration. This screen supports searching by source name or ID, bulk selection actions (select all, none, pinned, enabled), and pinning sources for easier access. A new configuration sheet (MigrationConfigScreenSheet) provides granular control over migration behavior, including toggles for data types to migrate (chapters, tags, etc.), options to remove downloads, hide unmatched entries, and hide entries without updates. Advanced options like deep search mode, prioritizing by chapters, and smart search for single entries are also available, along with an additional search query field for fine-tuning results.

app/src/main/java/mihon/feature/migration/config · high confidence

This update introduces a suite of new Compose UI components to the presentation layer, including an adaptive sheet dialog that centers on tablets and anchors to the bottom on phones, a new app bar with action mode support, and a tabbed dialog wrapper. It also adds a bulk selection toolbar for mass operations, a download dropdown menu with specific chapter count options (1, 5, 10, 25), and a custom dropdown menu implementation that overlaps its trigger. Additional changes include a new banner system for app states (restoring, syncing, updating), a source search box with animated visibility, and a custom chip component. The update also includes an AroundLayout for complex positioning and a SpinnerAdapter for Android View integration.

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

The presentation-core module has been introduced to centralize shared UI components and utilities. This includes a new AdaptiveSheet that adapts its behavior for tablet versus non-tablet devices, a CombinedCircularProgressIndicator that provides continuous rotation feedback, and various reusable settings items (checkboxes, sliders, radio buttons) and list components (LazyColumn/LazyGrid with fast scrollers and scrollbars). The module also adds utility functions for paging data collection and standardizes UI elements like ActionButtons, Badges, and Pills across the application.

presentation-core · high confidence

The reader now offers five distinct navigation layout options, replacing the previous single-tap mechanism. Users can choose from 'Disabled' (no tap zones), 'Edge' (previous/next on screen edges), 'Kindlish' (previous on left, next on right), 'L' (previous on top/left, next on bottom/right), and 'Right/Left' (move right/left via tap zones). These new layouts provide more granular control over how page turning and menu access are triggered within the viewer.

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

Users can now access a dedicated screen to manage sort tags, allowing them to create new tags, delete existing ones, and reorder the list using move-up and move-down actions. This feature is implemented using the Voyager navigation library and includes user feedback via toast notifications for errors such as duplicate tag names or internal failures.

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

A new \StatsOverviewItem\ composable has been added to the stats screen, providing a consistent UI for displaying statistical data with a title, subtitle, and an optional icon. This component utilizes Material 3 typography and theming to ensure visual consistency across the application's statistics display.

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

The app now presents a multi-step onboarding experience upon first launch, guiding users through initial configuration. The flow includes a theme selection step to customize the app's appearance, a storage configuration step that validates the selected data directory, a permissions step to request necessary access (including external storage, notifications, and battery optimization) and optionally enable crash reporting, and a guides step that provides links to getting-started documentation and backup restoration. This replaces the previous ad-hoc permission and storage checks with a cohesive, animated UI sequence.

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

The sync service layer now includes two new implementations: WebDAVSyncService, which allows users to synchronize their library data with any WebDAV-compatible server, and SyncYomiSyncService, which adds support for the SyncYomi cross-device synchronization protocol. These new services complement the existing Google Drive sync capability by providing additional remote storage and synchronization options.

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

The More screen now includes dedicated Compose UI components for displaying update information: ComingUpdatesScreen, NewUpdateScreen, and WhatsNewScreen. These screens present changelogs using Markdown rendering (GFM flavour), allowing users to view formatted release notes directly within the app. The NewUpdateScreen handles available updates with accept/reject actions, the ComingUpdatesScreen previews upcoming changes, and the WhatsNewScreen shows what has changed in the current version. A LogoHeader component provides consistent branding at the top of the More screen.

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

This change introduces a suite of new utility classes in the app's core utilities package to enhance content handling and source management. Users can now benefit from improved data saving options, including support for the wsrv.nl service and Bandwidth Hero proxy with configurable image quality and format conversion. The app now features more robust detection for manga types (such as webtoon, manhwa, and manhua) and includes a dedicated checker to identify lewd content based on source and genre tags. Additionally, a new URL import feature allows users to quickly add galleries by pasting a URL into a source's search bar, while background request throttling helps manage network load more effectively.

app/src/main/java/exh/util · high confidence

The app now includes three new widget classes to support enhanced UI features. AutoCompleteAdapter provides a custom adapter with prefix-aware filtering for search inputs. TachiyomiTextInputEditText automatically applies the IME\_FLAG\_NO\_PERSONALIZED\_LEARNING flag when incognito mode is enabled, helping prevent input learning by the keyboard. ViewPagerAdapter offers a simplified base class for ViewPager adapters, reducing boilerplate in views that display paginated content.

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

The Advanced settings screen now includes a new 'Clear Database' interface that allows users to selectively remove manga entries while preserving their reading history. When initiating a database clear, a confirmation dialog appears with a toggle labeled 'Exclude read manga'; if enabled, only unread or untracked entries are removed, keeping the history for manga the user has already read. If the toggle is disabled, all history is cleared, accompanied by a warning message. This change provides finer control over data retention during database maintenance.

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

The manga migration screen now supports range selection, allowing users to select multiple items at once by long-pressing and dragging, in addition to individual taps. A new bottom bar provides controls to select all, invert selection, and clear selection. Users can also initiate a bulk migration for the selected items via a new configuration screen, or open individual manga details by tapping the cover image while in selection mode.

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

The Extension Details screen now includes a button to open the extension's website in an in-app WebView, and the Source Preferences screen has been migrated to use the Voyager navigation library with a Compose-based wrapper. This change also introduces per-extension incognito mode support, allowing users to toggle private browsing for specific sources directly from the details view.

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

Users can now import galleries by pasting a URL (such as a page or chapter link) into the search bar, which automatically detects the correct source and fetches the gallery details. Additionally, the app now handles migration of old source IDs (NHentai, Tsumino, HBrowse, EHentai, ExHentai) in backups and merged references, ensuring that libraries from previous versions continue to work correctly with the new delegated source system.

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

The application now supports 'merged' manga sources (identified by \MERGED\_SOURCE\_ID\) within the chapter domain layer. A new \GetAvailableScanlators\ interactor provides methods to retrieve scanlators based on merge IDs, and \SetReadStatus\ is updated to handle marking chapters as read/unread for merged sources by delegating to \GetMergedChaptersByMangaId\. Additionally, \SyncChaptersWithSource\ uses the original title (\ogTitle\) for chapter directory renaming checks to better handle sources with non-Unicode or special characters.

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

Users can now open specific manga or chapters directly from external links (such as share intents). The app introduces a new deep-link handling flow that resolves incoming URLs against installed sources; if a source supports the link, the app fetches the manga and chapter data, automatically downloading the manga if necessary, and navigates the user directly to the manga details or the chapter reader. If the URL cannot be resolved to a specific item, the app falls back to a global search for the query.

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

The sync module now includes a WebDAV synchronization service, allowing users to sync their library data to any WebDAV-compatible server in addition to existing options like Google Drive and SyncYomi. The background sync job has been updated to run as a foreground service with a progress notification, giving users real-time visibility into the sync status and the ability to cancel the operation if needed. The sync manager also handles backup and restore logic for the new service, ensuring data consistency across devices.

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

A new data model, SyncTriggerOptions, has been added to define the configuration for automatic synchronization triggers. This class manages four boolean settings—syncing on chapter read, chapter open, app start, and app resume—and provides utility methods to convert these settings to and from a boolean array, as well as a list of UI entries for each option.

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

The RecommendsScreen now pulls recommendations from multiple community sources, including AniList, MyAnimeList, MangaUpdates (both community and similar titles), Comick, and MangaDex. This change introduces a unified paging source architecture that fetches recommendations via tracker IDs or title searches, ensuring the screen remains functional even if specific extensions like MangaDex or Comick are not installed. Users will see a broader, more relevant set of suggestions based on their tracked manga and community data.

app/src/main/java/exh/recs/sources · high confidence

The Updates screen now supports filtering updates by status (downloaded, unread, started, bookmarked) and excluded scanlators via a new dialog. Updates are grouped by date with animated expand/collapse visibility, and users can perform whole-group or range selection for bulk actions like marking as read or deleting. The screen also introduces swipe actions for chapters and a confirmation dialog for deleting selected chapters.

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

The legacy \Manga\ data entity, which previously handled SQLite storage via the StorIO library, has been removed from the application. This change eliminates the internal class and its associated database mapping annotations, indicating a shift away from the previous data persistence implementation for manga records.

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

The application removes the \BaseActivity\ class, which previously handled back-stack navigation and dependency injection, and deletes the \MainActivity\ class that displayed a character list via a RecyclerView. This change eliminates the old activity-based UI structure in this module, likely as part of a broader migration to a fragment-based architecture or a different navigation pattern.

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

The legacy data-access helpers in the app's data layer have been removed. Specifically, DatabaseHelper (which wrapped StorIOSQLite for manga queries), DbOpenHelper (the SQLite schema manager), and PreferencesHelper (the shared-preferences wrapper) are no longer present. This cleanup eliminates duplicated or obsolete persistence code, implying that database and preference operations are now handled by newer, consolidated components elsewhere in the codebase.

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

The \DetailHolder\ class, which previously rendered individual detail items in the UI using the \easyadapter\ library, has been removed. This eliminates the specific view logic that displayed detail text and handled click events to open URLs, indicating a shift away from this legacy adapter implementation.

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

The app has removed several utility classes from the \util\ package that are no longer used, including \AndroidComponentUtil\, \DataUtils\, \DialogFactory\, \NetworkUtil\, \SnackbarFactory\, and \ViewUtils\. This cleanup reduces the codebase size and eliminates dead code related to component toggling, network checks, dialog creation, and view conversions.

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

The source management logic in the domain layer has been refactored into dedicated interactor classes (e.g., CreateSourceCategory, ToggleSource, GetEnabledSources). This change centralizes operations for enabling/disabling sources, managing pinned sources, handling source categories, and controlling incognito mode, providing a cleaner and more modular API for the UI layer to interact with source preferences and repository data.

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

The app introduces three new dependency-injection modules in the domain layer to organize and wire up specific business logic. \KMKDomainModule\ registers repositories and interactors for tracking library update errors, enabling the app to report and manage failures during library synchronization. \SYDomainModule\ adds support for source-specific features including saved searches, feed management, manga merging, and page previews, along with custom manga metadata handling. \DomainModule\ serves as the central registration point for core domain interactors covering categories, manga, chapters, history, tracks, extensions, and sources, ensuring these components are properly instantiated via the Injekt framework.

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

The tracking system has been restructured to improve maintainability and extensibility. A new abstract \BaseTracker\ class now provides common implementations for authentication, credential storage, and remote status updates, reducing code duplication across individual tracker services. New interfaces, \EnhancedTracker\ and \DeletableTracker\, define capabilities for automatic source binding and entry deletion, respectively. The \TrackerManager\ has been updated to include new tracker instances (Kavita, Suwayomi) and reorganized IDs, while the \TrackStatus\ enum centralizes status mapping logic for all supported trackers.

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

The About screen now includes a dedicated "What's New" option that opens a changelog screen, and the update check dialog features an "OK" button instead of "Cancel" with an additional option to view the changelog. Additionally, the app now uses the Material3 version of the AboutLibraries library to display open-source licenses, providing a modern UI for viewing library details and licenses.

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

The app now includes a local AIDL interface (IShellInterface) for Shizuku communication, defining methods to install an APK via AssetFileDescriptor and to destroy the session. This change aligns the local interface definition with the Shizuku library update to version 13.1.5.

app/src/main/aidl · high confidence

The AniList tracking integration has been completely rewritten to use the AniList API v2 via GraphQL, replacing the previous HTTP/JSON approach. This change introduces support for private tracking, allows users to configure score display formats (10-point, 100-point, 5-star, smiley, and 10-point decimal), and automatically updates the tracker status to 'Completed' when the final chapter is read. The implementation now uses Kotlin coroutines for asynchronous operations and includes improved error handling for token expiration and API downtime.

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

The AniList tracker integration has been updated to include staff details in search results. New data classes in the DTO layer (such as ALStaff, ALEdge, and ALStaffNode) parse the staff GraphQL responses, and the ALManga class now maps this data to populate the authors and artists fields in the app's track model, allowing users to see creator information alongside manga metadata.

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

The application entry point (App.kt) has been rewritten to integrate Coil 3 for image loading, XLog for configurable logging, and Injekt for dependency injection, while also adding TLS 1.3 support for older Android versions and incognito mode notifications. Additionally, a new AppInfo.kt file exposes the app's version code, version name, and supported image MIME types to extensions via the extension-lib API.

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

The app lock mechanism now supports configurable time ranges and specific days of the week, allowing users to restrict access only during selected hours or on selected days rather than always or never. Additionally, the application introduces a wide selection of new visual themes, including Nord, Catppuccin, Lavender, Monochrome, Tidal Wave, and several others, giving users more customization options for the app's appearance.

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

The app now includes dynamic shortcuts for the Library, Recently Updated, Recently Read, and Catalogues sections, allowing users to jump directly to these areas from the home screen. Additionally, the ProGuard configuration has been significantly expanded to preserve classes and members for Kotlin serialization, RxJava, OkHttp, and various other dependencies, ensuring that release builds do not crash due to obfuscation or optimization issues.

app · high confidence

The app update mechanism has been replaced with a WorkManager-based architecture, introducing dedicated jobs for periodic checking, downloading, and handling installation broadcasts. This change brings several user-facing improvements: users can now disable automatic background downloads, and the update check frequency is managed via a scheduled job. Notifications have been enhanced with specific actions, including a button to open the GitHub release page, a cancel button for downloads, and manual install/retry options for errors. The system also supports resuming interrupted downloads and displays distinct notifications for F-Droid versus standard builds, while ensuring update checks are skipped on unsupported Android versions.

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

The backup creation logic has been split into dedicated, single-responsibility classes (Categories, ExtensionStores, Feed, Manga, Preference, SavedSearch, and Sources) to improve maintainability. This refactor introduces support for backing up new data types, including global and source-specific feeds, saved searches, extension stores, and excluded scanlators. The Manga backup creator now includes custom manga metadata (title, artist, author, description, genre, status, thumbnail), the manga's 'initialized' status, and notes. Additionally, the Preference backup creator now supports an option to include or exclude private preferences during manual backup creation.

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

The backup system has been rewritten to use a new protobuf-based format, replacing the previous implementation. This change expands what can be backed up and restored, now including extension stores, source preferences, global popular/latest feeds, saved searches, hidden categories, merged manga references, and custom metadata (search tags and titles). The new format also supports storing user manga notes, the manga initialized status, and custom thumbnail URLs, ensuring these details are preserved during migration.

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

The Biometric Times screen now uses a Compose-based implementation for its list of time ranges. This change introduces new UI components (BiometricTimesContent and BiometricTimesListItem) that render the list using LazyColumn with item animations and Material 3 styling, replacing the previous non-Compose list implementation.

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

The Browse, Extension, Feed, Global Search, and Migrate screens have been rewritten in Jetpack Compose, replacing the previous XML-based implementations. This update introduces bulk selection capabilities across these areas, allowing users to favorite or manage multiple items at once. Additionally, the Browse Source screen now supports a Panorama cover display mode, and the Extension Details screen includes a button to open the extension's website in a WebView.

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

The build logic has been reorganized into dedicated configuration files. Android SDK targets are now centrally defined, setting both compile and target SDK to 36 with a minimum SDK of 26, and requiring Java/Kotlin 17. Build variants can now include telemetry via the 'include-telemetry' flag (replacing the previous 'include-analytics' naming) and control updater/code-shrink features. Additionally, the build process now injects precise build timestamps—using the last commit time for releases or current time for previews—and exposes git commit metadata, enhancing traceability for generated builds.

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

The category management interface has been rebuilt using Jetpack Compose, introducing new dialog components for creating, renaming, and deleting categories with improved input validation and focus handling. A key behavioral addition is the ability to hide categories, which is now supported in the list item UI through a dedicated toggle button and visual indicators (dimmed text and strikethrough) for hidden items. The list items also support drag-and-drop reordering, and the floating action button has been updated to use the Material 3 extended style.

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

The Category, Source Category, Sort Tag, and Biometric Times screens have been rewritten in Jetpack Compose, replacing the previous implementation. This update introduces drag-and-drop reordering for categories in the main Category screen, allowing users to quickly change the display order. Additionally, a new 'hide' action has been added to categories, giving users more control over their library organization. The screens now use a consistent Material 3 Scaffold and AppBar pattern, improving visual consistency across the app.

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

The application now consolidates user interface settings into a dedicated \UiPreferences\ class, providing a single point of access for configuration options such as theme modes, color themes, cover-based theming styles, panorama cover flow settings, and layout behaviors like read button positioning and feed tab visibility.

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

Source-specific settings are now managed through a dedicated SourcePreferences class, consolidating options for source display modes, language filters, pinned sources, and incognito mode. This change also introduces new user controls for migration behavior, including smart search toggles for single entries, prioritization by chapters, and hiding unmatched or outdated results, alongside data saver improvements and support for disabling specific extension repositories.

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

The new BaseActivity class consolidates core application behaviors by delegating secure screen management and theming logic to dedicated delegate classes. It also ensures the app theme is applied during activity creation and prepares the context for tablet UI support, providing a unified foundation for all activities in the app.

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

The app now intercepts uncaught exceptions with a GlobalExceptionHandler that serializes the error details and launches a new CrashActivity. This activity displays a CrashScreen UI showing the exception information and offers a restart option to return to the main interface, ensuring users see a clear error state rather than experiencing an abrupt, silent termination.

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

The app now includes a custom Compose-based debug overlay (EHDebugModeOverlay) that displays real-time FPS, build type, version, commit SHA, current log level, and source blacklist status directly on screen. Additionally, logging infrastructure has been enhanced with a new EnhancedFilePrinter for robust, configurable file-based log storage (including backup and cleanup strategies) and an XLogLogcatLogger bridge to integrate XLog with the logcat system.

app/src/main/java/exh/log · high confidence

The app now supports more consistent custom theming for alert dialogs, allowing dialog backgrounds, text, and input fields to reflect the current color scheme. A new extension function simplifies creating dialogs with a text input field, automatically handling focus and soft keyboard display. Additionally, dialog backgrounds now feature rounded corners for a more modern appearance.

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

The merged manga settings dialog now supports custom theme colors for UI components such as spinners, switches, and list items, ensuring visual consistency with the user's selected color scheme. Additionally, users can now tap a manga's cover image in the merged list to open its individual entry, providing quicker access to source details.

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

The database model layer for chapters and tracking history has been rewritten in Kotlin, introducing new \Chapter\ and \Track\ interfaces and their implementations (\ChapterImpl\, \TrackImpl\). This change updates the underlying data structures used to store reading progress and library sync information, including the addition of a \memo\ field to chapters and a \private\ flag to tracks, which supports new features like chapter bookmarking and private tracking.

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

The app now handles delayed tracker updates more reliably by introducing a dedicated background job that retries failed updates up to three times before giving up, preventing permanent loss of read progress when network errors occur. Additionally, a new preference allows the app to automatically sync read progress from external trackers back to the local library, ensuring your local state stays consistent with what is stored on the tracker service.

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

The download queue screen has been rewritten in Compose and now groups downloads by their source, displaying each source as an expandable header. Additionally, a new menu option allows users to navigate directly to the manga page from a download item.

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

The E-Hentai login interface has been rewritten using Jetpack Compose, replacing the previous implementation. This update introduces the ability to set a custom 'igneous' cookie via a new dialog, which is applied during the login process to ensure successful authentication. The login flow now handles Cloudflare guard detection to prevent blank pages and supports alternative login pages and page restyling options. Additionally, the activity uses modern Android transition APIs where available, improving the visual consistency of the login screen.

app/src/main/java/exh/ui/login · high confidence

The application's E-Hentai tag data has been reorganized from a single monolithic list into multiple Kotlin files categorized by tag type (Artist, Character, Group, Parody, etc.). This change improves code maintainability and potentially reduces memory overhead by splitting the large dataset into smaller, manageable units, while preserving the full set of available tags for users.

app/src/main/java/exh/eh/tags · high confidence

The migration process now preserves more user data by copying the last page read and history records when migrating manga, and it supports migrating tracker entries and custom cover images. Additionally, the remote update mechanism for sources (specifically EHentai) now supports throttling to manage request rates, and the update process returns a structured result containing both the updated manga details and any newly fetched chapters.

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

The Sources screen now includes an NSFW filter toggle to show only adult sources, supports grouping sources by custom categories via a new dialog, and allows excluding specific sources from data saver mode. Additionally, long-pressing a source provides access to these new settings alongside existing pin and disable options, and the source filter screen now supports bulk toggling of sources.

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

The tracker search functionality now displays richer information for manga entries, including author and artist names, cover images, summaries, and publishing status. This is enabled by new model classes (TrackMangaMetadata and TrackSearch) that extend the core tracking data with these additional fields, allowing users to see more context when searching for titles across supported trackers.

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

The ExtensionManager has been rewritten to use Kotlin Flows for managing extension states, providing a more reactive and consistent UI experience. A key behavioral change is the introduction of source blacklisting, which allows users to hide specific extensions from the available list based on configurable preferences. Additionally, the manager now supports custom icons for specific sources (such as ExHentai and merged sources) via ContextCompat, ensuring visual consistency in the UI. The logic for handling untrusted and installed extensions has also been refined to filter blacklisted items during initialization, improving security and user control over which extensions are visible and loadable.

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

The extension update notification system has been updated to align with user privacy preferences and source management settings. Notifications will no longer display the names of extensions if the 'Hide notification content' privacy setting is enabled. Additionally, the update check logic now respects the source blacklist, ensuring that blacklisted sources are excluded from update checks and notifications. The notification UI has also been refined to use the app's launcher icon color and a specific large icon for better visual consistency.

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

The Extensions tab has been rewritten in Compose using the Voyager navigation library, introducing a dedicated filter screen for managing language preferences and adding a toggle to show only NSFW sources. The new implementation includes a confirmation dialog when removing privately installed extensions, allows opening source websites in a WebView, and supports clearing the search query by pressing Back.

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

The History screen now supports filtering entries by unfinished manga/chapters and non-library items, as well as multi-selection and batch operations (delete, favorite). A new filter dialog is integrated into the UI, and the screen is exposed as a dedicated tab in the bottom navigation, with a preference to show or hide it. The screen model also handles duplicate manga detection and migration dialogs within this context.

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

The History screen has been rewritten in Jetpack Compose, introducing multi-item selection and batch operations (such as clearing history for selected items) via a new selection mode. A filter button has been added to the app bar to allow users to filter history entries, and the UI now supports panorama-style covers. The screen also includes a dedicated empty state for when no history is found or when search yields no results, and utilizes relative date headers for grouping entries.

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

The tracking system now provides clearer feedback when progress is synced from external trackers by displaying a toast notification. Additionally, the synchronization logic has been refined to better handle local chapter read status updates, ensuring that continuous incremental chapters are marked as read based on the tracker's data, and preventing the automatic marking of chapter 1 as read for trackers in specific states like 'Wishlist' or 'Plan to read'.

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

The pager-based manga reader now supports granular control over zoom behavior and navigation regions. Users can disable zoom-in entirely, toggle double-tap zoom, and choose how landscape images are scaled (fit, center, or focus). Navigation tap zones can be adjusted for smaller touch areas, and the navigation layout can be inverted independently for the pager mode. These settings are managed via the new PagerConfig and applied through the Pager, PagerViewer, and PagerPageHolder components.

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

A new \Download\ data class has been added to the download model layer to represent a single download unit, encapsulating the associated \HttpSource\, \Manga\, and \Chapter\. This model exposes reactive state flows for download status and progress, allowing the UI to observe real-time changes in the download queue.

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

The reader module now includes a set of new model classes to handle chapter transitions, page insertion, and chapter state tracking. Specifically, \ChapterTransition\ defines navigation between chapters with equality logic, \InsertPage\ handles special page states, \ReaderChapter\ manages chapter loading states and resource reference counting, \ReaderItem\ serves as a common interface, \ReaderPage\ extends page data with layout flags, and \ViewerChapters\ coordinates reference counting for the current viewing context. These changes support the underlying reader infrastructure updates.

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

The Kitsu tracker implementation has been completely replaced with a new Kotlin-based client that uses OkHttp and kotlinx.serialization instead of the previous Retrofit and Gson stack. This update introduces private tracking support, allowing users to keep their reading lists hidden from public view. The tracking logic has been refined to automatically set the status to 'Completed' only when the final chapter is read, and to 'Reading' when chapters are read but the series is not finished, while preventing the start date from being set for entries in 'Plan to Read' or 'Wishlist' states. Search results now explicitly filter out novels, and the API client handles OAuth token refresh automatically. Additionally, the tracker now correctly maps the Kitsu 20-point rating system to the app's internal scoring and includes manga metadata in library entry responses for more accurate synchronization.

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

The Kitsu tracking integration has been updated to support private tracking, allowing users to hide their reading activity from public view on the Kitsu platform. This change is implemented by introducing a set of new data classes (DTOs) in the \kitsu/dto\ package to strictly parse API responses for search, user lists, and metadata, replacing previous ad-hoc parsing. The update also corrects data handling for fields like \synopsis\ and \ratingTwenty\ to ensure accurate display of summaries and scores.

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

The library tab has been rewritten to use the Voyager navigation library and Jetpack Compose, replacing the previous implementation. This change introduces new screen models (LibraryScreenModel, LibrarySettingsScreenModel) to manage library state, filtering, and settings, and updates the main LibraryTab composable to use Voyager's Tab and Navigator APIs. The migration also includes the addition of a new LibraryItem data class to represent library entries in the UI layer.

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

The library display has been significantly updated with new visual elements and layout options. Manga items now feature source icons and language flags (using emoji flags) as badges, replacing the previous text-based language indicators. A new 'Comfortable Grid' display mode is available, which supports a 'Panorama' cover style for wider images. Additionally, the 'Continue Reading' button is now only visible for manga with unread chapters, and the library tabs and counts are always shown during search.

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

The library settings dialog has been rewritten in Compose, introducing a tabbed interface with dedicated pages for filtering, sorting, display, and grouping. This update adds new filtering capabilities, including the ability to filter by custom categories and lewd content, and enables hidden categories by default. Additionally, a new Compose-based dialog for deleting library items allows users to selectively remove manga from the library while optionally deleting local files and downloaded chapters.

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

The library update mechanism in the app has been refactored to support manual refresh actions and better error handling. The new LibraryUpdateJob now includes logic to handle manual library updates, allowing users to refresh selected manga entries directly from the library screen. Additionally, the job now tracks and reports update errors, providing users with clearer feedback when updates fail, including the ability to view detailed error logs. This change also integrates with the existing notification system to provide real-time progress updates and error notifications during library updates.

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

The local source now allows users to enable hidden folders (those starting with a dot) via a new setting, and supports encrypted cover images (CBZ format) for local series. This change introduces an \encrypted\ flag to the cover update logic, allowing covers to be stored in encrypted archives, and filters out hidden directories by default unless the new option is enabled.

source-local · high confidence

The main activity has been completely rewritten using Jetpack Compose and the Voyager navigation library, replacing the previous Conductor-based architecture. This change introduces a modern UI stack that handles system insets, edge-to-edge display, and splash screen integration natively within the Compose hierarchy. Users will experience smoother screen transitions and a unified layout structure for the home, browse, and more screens, which are now implemented as Voyager screens rather than Conductor controllers.

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

The manga list and detail components have been rewritten in Jetpack Compose, introducing several user-facing changes. Manga list items now support long-press actions with haptic feedback, and chapter list items feature configurable swipe actions for quick management. The manga cover display has been enhanced with a new 'Panorama' aspect ratio option and improved loading/error states. Additionally, the chapter list header now displays a warning count for missing chapters, and the bottom action menu includes confirmation steps for destructive actions like deletion.

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

The manga detail screen has been significantly restructured with a new Compose-based UI, introducing a dedicated dialog for chapter settings (filtering, sorting, display) and a new screen for editing manga notes. The main screen now supports a panorama cover view, configurable page previews, and displays a missing chapter count. Duplicate manga handling has been improved with a new dialog that allows migration and bulk-favorite actions, while the related titles section has been moved to a separate screen. Additional behavioral changes include allowing partially read chapters to be marked as unread, enabling the deletion of downloaded chapters even if the source is unavailable, and adding haptic feedback before actions.

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

The MangaDex login and logout flows have been completely rewritten to use a new OAuth-based authentication system. A new \MangaDexAuthInterceptor\ now automatically handles token storage, expiration detection, and transparent token refreshing for API requests, while a new \MangaDexLoginHelper\ manages the login and logout processes using PKCE and official MangaDex endpoints. This change replaces the previous authentication mechanism to fix delegation issues and improve reliability during login and logout operations.

app/src/main/java/exh/md/network · high confidence

The MangaDex follows screen has been rewritten in Compose to include bulk favorite selection, allowing users to select multiple items at once via long-press or toolbar actions, and to migrate duplicate manga entries directly from the duplicate dialog.

app/src/main/java/exh/md/follows · high confidence

The MangaDex integration in the app has been restructured to support the latest API version and improved authentication. New utility files define API base URLs, constants, and language mappings, while a new \FollowStatus\ enum standardizes tracking states. Authentication now uses PKCE (Proof Key for Code Exchange) for secure OAuth flows, and description cleaning logic has been updated to better handle titles and formatting.

app/src/main/java/exh/md/utils · high confidence

The MangaDex similar titles feature has been refactored to use the new RecommendationPagingSource infrastructure. This change integrates the existing similar/related logic into the broader recommendation system, allowing the feature to leverage unified batch processing and sorting capabilities while maintaining the specific data fetching behavior for MangaDex.

app/src/main/java/exh/md/similar · high confidence

The MangaUpdates integration has been updated to handle both legacy numeric IDs and newer base36 IDs, automatically converting legacy IDs via a redirect to ensure seamless tracking from other sources. The tracker now fetches detailed metadata including authors and artists, and correctly distinguishes between 'Wish List' and 'Reading' statuses to prevent marking a series as read when it is only wished for.

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

The MangaUpdates tracking integration has been refactored to use dedicated data classes (DTOs) for parsing API responses, replacing previous parsing logic. This change introduces specific models for session context, login responses, search results, series details, and user list items, ensuring that tracking data such as status, chapters, and ratings is mapped more reliably to the app's internal track model.

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

The metadata view screen now applies a theme derived from the manga's cover color when the 'theme based on cover' setting is enabled. This is implemented by passing a seed color to the TachiyomiTheme wrapper in the UI screen, which is determined by checking the user's preference in the screen model.

app/src/main/java/exh/ui/metadata · high confidence

The migration dialog UI now correctly displays user-friendly labels for the 'Track' and 'Extra' migration flags, in addition to the existing labels for chapters, categories, custom covers, notes, and downloaded items. This ensures that users see clear descriptions for all available migration options when migrating manga data.

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

The MyAnimeList integration has been rewritten to use the official MyAnimeList API, replacing the previous implementation. This update introduces several user-facing improvements: search results now include NSFW content, authors, artists, and average scores, while novel results are filtered out. Users can search by MyAnimeList ID (using the 'id:' prefix) or by searching their own list items (using the 'my:' prefix). The tracker now properly handles unapproved titles by displaying an informative error message instead of failing silently, and automatically sets the status to 'Completed' with a finish date when the final chapter is read. Additionally, the authentication flow has been stabilized to handle token expiration more gracefully, preventing unnecessary login prompts.

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

The Source Category screen now uses a new Compose-based implementation (SourceCategoryContent and SourceCategoryListItem) to display and manage categories. Users will see a list of source categories rendered in ElevatedCards, each showing a label icon and the category name. Tapping a card or the edit icon allows renaming the category, while the delete icon removes it. The list supports smooth animations for item changes and respects system animation settings.

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

The settings UI has been rewritten using Jetpack Compose, introducing a new data-driven preference model (Preference.kt) that supports various item types including switches, sliders, lists, and custom content. This change replaces the previous Android XML-based preference hierarchy with a unified Compose rendering engine (PreferenceItem.kt, PreferenceScreen.kt) that handles state observation, animations, and layout grouping. The new system also introduces a dedicated scaffold (PreferenceScaffold.kt) for consistent app bar and navigation handling within settings screens.

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

The settings screen now uses a new set of Compose UI components in the \widget\ package to render preference items. This includes \AppThemePreferenceWidget\ for selecting and previewing themes, \AppThemeModePreferenceWidget\ for choosing light/dark/system modes, \ThemeColorPickerWidget\ for custom color selection, \EditTextPreferenceWidget\ for text input, \ListPreferenceWidget\ and \MultiSelectListPreferenceWidget\ for single and multi-choice selections, \TriStateListDialog\ for three-state list options, and supporting widgets like \SwitchPreferenceWidget\, \ConnectionPreferenceWidget\, \TrackingPreferenceWidget\, and \InfoWidget\. These replace previous implementations with a unified, Material 3-styled interface that provides live theme previews, inline color picking, and consistent dialog-based selection flows.

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

The app introduces a new ImageSaver class in the data saver module to handle saving images. For devices running Android 10 (API 29) and above, it now saves pages and covers directly to the MediaStore using the public Pictures or Documents directories, ensuring files are immediately visible in the system gallery. It overwrites existing files with the same name in the same location rather than creating duplicates, sets the modification time to the current time, and triggers a media scan to update the system index. For older Android versions, it falls back to saving files directly to the app's cache directory.

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

Users now see real-time progress banners for library updates, sync, and backup/restore operations via the new BannerProgressStatus classes, which debounce rapid state changes to avoid UI flicker. The backup and restore process notifications have been split into separate progress and completion channels, with clearer error messages, share actions for completed backups, and better handling of missing sources or trackers during validation. Duplicate notifications during backup/restore are prevented, and progress updates are synchronized with the banner indicators for a consistent experience.

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

The app now provides distinct, dedicated screens for managing data operations, replacing previous inline or dialog-based interfaces. Users can now configure backup options (library and settings) in a new Create Backup screen, select specific data to restore in a Restore Backup screen that validates files and shows detailed error messages, and choose exactly which data categories to sync in a new Sync Settings Selector screen. Additionally, sync trigger options are now managed in their own screen. These changes improve clarity and control over data management tasks.

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

The app now uses a dedicated foreground service (ExtensionInstallService) and broadcast receiver (ExtensionInstallReceiver) to handle extension installation, updates, and removals, replacing the previous direct installation approach. This change introduces support for private extensions stored in the app's data directory alongside shared system extensions, with the ExtensionLoader now prioritizing shared extensions and handling version conflicts. The installer also supports multiple backend strategies (PackageInstaller, Shizuku, and a legacy mode) and includes a workaround for MIUI package installer bugs to prevent installation result loss.

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

The migration list feature has been refactored into a new screen at \mihon.feature.migration.list\ that supports mass migration of selected library items. This screen introduces a smart search engine that uses Levenshtein distance to match manga titles, with an option to skip smart search for single-entry migrations to allow manual selection. It also includes request throttling for E-Hentai sources to prevent rate-limiting, and adds UI components for migration progress, exit confirmation, and configuration options.

app/src/main/java/mihon/feature/migration/list · high confidence

The app now introduces specific data structures to better manage the extension installation lifecycle and result handling. The new \InstallStep\ enum defines distinct phases for the installation process (Idle, Pending, Downloading, Installing, Installed, Error) and provides a helper to determine when a step is considered completed. Additionally, the \LoadResult\ sealed interface standardizes how extension loading outcomes are represented, distinguishing between successful loads, untrusted extensions, and errors, allowing the UI and logic to handle these states more explicitly.

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

This update introduces a suite of new utility functions in the presentation layer to improve user experience and code maintainability. Users will see more user-friendly, localized error messages for network and source issues, and chapter numbers are now formatted consistently with decimal precision. Navigation transitions have been refined to prevent duplicate key exceptions and reduce jank during fast scrolling by disabling unnecessary fade animations. Additionally, the app now handles package install permissions more smoothly by checking status on resume without blocking, and time displays use modern APIs for better relative time formatting.

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

The reader's page loading mechanism has been replaced with a new loader system that improves performance and expands format support. Archive files (CBZ/CBR) can now be cached to disk via a configurable setting to reduce memory usage, while EPUB support has been added for local reading. The system now handles merged manga sources by correctly resolving and loading pages from their constituent sources. Additionally, aggressive page preloading and data-saving options are available for online chapters to optimize loading speed and bandwidth usage.

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

The app introduces a suite of new utility files in the system package to standardize and improve core functionality. This includes \AuthenticatorUtil\ for handling biometric and device credential authentication, \AnimationExtensions\ to respect system animation scale settings, and \ChildFirstPathClassLoader\ to prioritize extension classpaths over the app's own. Network connectivity checks are refined in \NetworkExtensions\ and \NetworkStateTracker\ to accurately detect internet availability and Wi-Fi status. Additionally, \ContextExtensions\ consolidates clipboard, browser launching, and theme context logic, while \NotificationExtensions\ and \WorkManagerExtensions\ provide safer helpers for notifications and foreground workers. Build configuration flags for telemetry, updates, and build types are also centralized in \BuildConfig.kt\.

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

The app introduces new domain models for theming and UI behavior. AppTheme now defines a comprehensive set of visual themes including Nord, Catppuccin, Monochrome, and several community themes, while replacing deprecated options. ThemeMode provides a structured way to switch between Light, Dark, and System settings, wired directly to Android's AppCompatDelegate. Additionally, TabletUiMode defines specific layout behaviors for tablet devices such as automatic, always, landscape, and never modes.

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

The app now displays a dedicated, theme-aware metadata view for delegated sources (E-Hentai, NHentai, MangaDex, Pururin, EightMuses, and Lanraragi) instead of the generic description. This view surfaces key details—such as genre, rating, page count, uploader, and favorites—directly in the manga details screen with icons and colors that adapt to the current theme, and allows users to long-press any field to copy it to the clipboard.

app/src/main/java/exh/ui/metadata/adapters · high confidence

This change introduces three new Kotlin extension files in the view utilities package to standardize common UI operations. The \WindowExtensions\ file adds a \setSecureScreen\ function to easily toggle the secure flag on windows, supporting privacy features like incognito mode. The \ViewExtensions\ file provides reusable helpers for launching Compose content with consistent app theming (via \setComposeContent\ on both \ComponentActivity\ and \ComposeView\) and displaying popup menus (\popupMenu\), as well as a utility to check if a view is visible on screen. Additionally, \EditTextPreferenceExtensions\ exposes a package-private listener getter for \EditTextPreference\ to facilitate custom input handling in settings.

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

The app now uses a new SharedPreferencesDataStore class to manage user preferences, which acts as a bridge between the AndroidX Preference library and underlying SharedPreferences. This change ensures that preference data is handled through the modern AndroidX API surface, improving compatibility with the AndroidX migration and providing a more consistent way to read and write settings like booleans, integers, strings, and sets.

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

The application has been rebranded from Mangafeed to Komikku, including a new app icon, updated README, and a new application ID (app.komikku). This change also introduces the initial project scaffolding, including an AI agent guide (AGENTS.md), a Contributor Covenant Code of Conduct, and a Weblate configuration for translations. The legacy Travis CI build configuration has been removed, and standard repository files like .editorconfig, .gitattributes, and a Renovate configuration have been added to enforce formatting and dependency management.

(repo-wide) · high confidence

The reader module has been completely rewritten in Kotlin, replacing the previous Java-based Presenter pattern with a modern ViewModel architecture. The UI has been migrated to Jetpack Compose, introducing a new navigation overlay view and updated reader settings dialogs. This change also integrates Coil for image loading, improves state management for reading progress, and adds support for features like incognito mode tracking and merged manga handling within the reader flow.

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

The reader interface now includes a new ChapterNavigator component that displays the current page and total pages with a slider, supporting both horizontal and vertical layouts, and includes haptic feedback during slider interaction. Additionally, a ModeSelectionDialog component has been added to provide reading mode and orientation selection dialogs with separate Apply and Revert to Default buttons, improving the user experience for adjusting reader settings.

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

The reader interface has been migrated to Jetpack Compose, introducing new dialogs for selecting reading mode and orientation that now feature separate 'Use Default' and 'Apply' buttons. A new chapter list dialog displays download status and progress, allowing users to download chapters directly from the reader. E-ink display support is enhanced with configurable white/black page flashes and adjustable intervals. Additionally, users can now copy, share, and save individual or combined pages, and the chapter transition screen now indicates download states and warns about missing chapters.

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 a simplified layout that supports vertical chapter navigation (left or right side) alongside the existing bottom bar. This change adds a new 'ExhUtils' panel to the top bar for auto-scroll and retry controls, and updates the bottom bar to use Material 3 icon tints and conditional button rendering based on enabled settings.

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

The reader settings interface has been migrated from the legacy preferences system to a new Compose-based implementation. This change introduces dedicated UI components for managing reader behaviors, including a customizable bottom button menu, screen orientation controls, and reading mode selection. Users can now adjust settings such as double-tap zoom, pinch-to-zoom, and navigation regions through a modern, consistent settings screen.

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

The reader settings interface has been rebuilt using Jetpack Compose, replacing the legacy Android preference system. This change introduces a new tabbed dialog layout containing Reading Mode, General, and Color Filter pages, 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 (progress indicator, transition view, and image viewer) have been rewritten using Jetpack Compose and now respect the cover-based theme setting, allowing the reader's loading and transition text colors to adapt to the manga cover. Additionally, a new custom gesture detector handles long taps without conflicting with quick scale, and a specialized button class ensures tap gestures on viewer controls are correctly intercepted.

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

The More tab has been rebuilt using the Voyager navigation library, introducing dedicated screens for onboarding, new updates, coming updates, and what's new. The onboarding experience now prevents users from backing out before completion and offers a direct path to restore backups. The More tab screen itself now displays download queue status, supports incognito and downloaded-only filters, and includes navigation to library update errors, batch add, history, and updates. Additionally, Discord Rich Presence integration has been added to the More tab.

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

The home screen has been rewritten in Jetpack Compose to support both mobile and tablet layouts. On tablets, a navigation rail is displayed, while mobile devices use a bottom navigation bar. The implementation includes a 'predictive back' animation for smoother transitions and ensures the back button returns users to the Library tab when they are on other screens. It also introduces a static key for the tab navigator to prevent crashes and allows for hiding the updates count badge via preferences.

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

The tracker interface has been rebuilt using modern Compose components, introducing a new home dialog (TrackInfoDialogHome) that displays tracked items with support for private tracking indicators and context menu actions like copying links. The search experience (TrackerSearch) now uses a TextFieldState-based input with improved keyboard handling and explicitly supports creating private tracks. Selector dialogs for status, chapters, scores, and dates have been updated to use Material 3 components, including a native date picker for date selection.

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

The extension domain layer has been restructured into specific interactors: GetExtensionLanguages now provides a sorted list of available languages with a comprehensive mapping of language codes to specific country flag icons (e.g., using South Africa's flag for Afrikaans); GetExtensionSources handles per-source enablement logic for multi-source extensions; GetExtensionsByType consolidates the retrieval of updates, installed, available, and untrusted extensions while filtering by NSFW preferences and language; and TrustExtension introduces a debug-build bypass and a specific signature check for 'KOMIKKU\_SIGNATURE' to streamline the trust process. These changes are accompanied by a new Extensions data model to group these states.

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

The notification system has been restructured to improve maintainability and clarity. A new \NotificationHandler\ object centralizes the creation of \PendingIntent\s for common actions like opening the download manager, viewing images, installing APKs, and opening URLs, ensuring consistent intent flags (such as \FLAG\_IMMUTABLE\). A new \NotificationReceiver\ class replaces the previous inline broadcast handling, explicitly routing actions for downloads (pause/resume/clear), library updates, backups, and chapter interactions (open/marked as read) to their respective services and domain models. Additionally, the \Notifications\ object now explicitly defines and creates all notification channels and groups (Library, Downloader, Backup/Restore, Updates) while deleting deprecated channels, standardizing how notification importance and grouping are applied across the app.

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

The extension installer preference now automatically adapts to the device environment: on MIUI devices, the legacy installer is selected by default and the standard package installer option is hidden to avoid installation issues, while Shizuku is only offered if the service is detected. This change ensures a smoother extension installation experience by preventing invalid selections based on system capabilities.

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

The extension installation logic has been restructured into a base \Installer\ class with specific implementations for \PackageInstallerInstaller\ and \ShizukuInstaller\. This change introduces a synchronized queue to prevent duplicate entries and fixes crashes that occurred during mass install/uninstall operations or when Shizuku was unavailable. The \PackageInstallerInstaller\ now correctly handles intent sanitization and session management, while the \ShizukuInstaller\ includes better error handling for shell interface availability and receiver unregistration, ensuring more reliable extension updates across different Android versions and user setups.

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

The chapter utility layer has been updated to improve how downloaded chapters are identified and processed. The new \ChapterFilterDownloaded\ utility correctly filters out non-downloaded chapters in the reader when the 'Downloaded Only' option is enabled, including proper handling for local manga sources. Duplicate chapter removal logic has been refined to prioritize matching by chapter number and scanlator, ensuring cleaner lists during download-ahead operations. Additionally, the 'next unread' calculation now includes special handling for Eh-based manga to respect sort direction more accurately, preventing incorrect chapter navigation in specific library configurations.

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

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

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

The application's legacy dependency injection infrastructure has been removed. Specifically, the \App\ class, \AppComponent\ interface, and \AppModule\ class, which previously handled Dagger 1 initialization and application-level singleton provisioning, have been deleted from the codebase. This indicates a migration away from the older Dagger 1 framework, likely to a newer version or a different DI solution, simplifying the app's startup and dependency management.

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

The database table schema definitions for Categories, Chapters, Mangas, and the Mangas-Categories relationship have been removed from the application. This cleanup eliminates the legacy SQL table creation logic and column constants that were previously used to define the local data structure, indicating a shift in how the application manages its persistent storage.

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

The build system now uses Spotless with ktlint for automatic code formatting, replacing the previous detekt-based linting approach. This change introduces a set of standardized Gradle convention plugins (such as mihon.android.application, mihon.library, and mihon.code.lint) that centralize Android configuration, Compose setup, and linting rules, ensuring consistent code style and build behavior across the project.

buildSrc/src/main/kotlin · high confidence

The backup restore process now correctly handles several previously broken or missing settings. Hidden categories are restored with their visibility state preserved, and pinned sources are correctly restored from backups that were previously ignored. Additionally, extension store configurations are migrated to support newer index formats, and the app update job is re-initialized after preferences are restored to ensure scheduled checks resume correctly.

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

The download system has been rewritten to replace the previous service-based implementation with Android's WorkManager for background execution and Kotlin Coroutines for asynchronous logic. This change introduces a new DownloadCache to optimize filesystem checks, migrates the downloader service to a foreground WorkManager job (DownloadJob), and updates the download queue and notifier to use modern reactive streams (SharedFlow/StateFlow). Users benefit from more reliable background downloads that survive app restarts and system reboots, improved performance in the download queue UI, and better handling of network state changes.

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

The application's migration infrastructure has been completely rewritten to ensure reliable data preservation during upgrades. This update introduces a suite of new migration scripts that handle critical user data transitions, including migrating legacy source IDs for NHentai and EHentai, rewriting complex merged manga references, and correcting chapter URL hash preferences for existing users. It also addresses specific platform issues, such as forcing a logout from MyAnimeList and MangaDex due to login flow changes, and automatically switching the extension installer to 'Legacy' mode for MIUI devices. Furthermore, the system now cleans up obsolete preferences, such as removing broken category references and migrating various settings (like library sorting, reader tap modes, and encryption keys) to their new storage locations, ensuring a seamless experience for returning users.

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

The migration logic in the app has been rewritten to support more robust data transitions. A key behavioral change is the ability to merge old source references into new ones, ensuring that source IDs, pinned sources, saved searches, and feeds are correctly migrated when sources are combined. The new system uses a strategy-based approach (Initial, VersionRange, Noop) to execute migrations sequentially based on version numbers, improving reliability and allowing for dry-run testing.

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

The Settings screen has been rewritten to use the Voyager navigation library, replacing the previous implementation. This change introduces a dedicated two-pane layout for tablet devices, displaying the main settings list alongside the selected sub-screen (such as Appearance, Data and Storage, or Tracking) simultaneously. For non-tablet devices, the navigation remains a standard single-pane stack. The screen now explicitly handles system bar insets for proper padding on tablets and uses unique destination keys to prevent state-saving crashes.

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

The settings screens in the 'More' section (Advanced, Appearance, Browse, Connection, Data, Discord, etc.) have been rewritten using Jetpack Compose and the Voyager navigation library. This change replaces the previous XML-based preference system with a modern Compose UI, introducing a new \SearchableSettings\ interface to standardize how settings screens are structured and navigated within the app.

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

The Shikimori tracker integration has been completely rewritten to use a new API client structure, migrating from the previous implementation to one based on kotlinx.serialization and coroutines. This change updates the underlying HTTP client to use OkHttp with a custom interceptor for OAuth token management and refresh logic, and switches the API base URL to shikimori.one. The tracker now supports fetching detailed manga metadata (including authors and artists) via a GraphQL endpoint, and improves status synchronization logic to automatically mark entries as completed when the last chapter is read. User-facing status labels have been mapped to Shikimori's specific terminology (e.g., 'watching', 'rewatching').

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

The smart search feature has been refactored into a new Compose-based screen and screen model. A key behavioral change for users merging manga is that when a match is found, the resulting manga screen is opened with the description collapsed. This ensures the 'Merge with another' button remains visible, allowing users to easily select a different target entry without having to manually expand the description first.

app/src/main/java/exh/ui/smartsearch · high confidence

The source-api module has been converted to Kotlin Multiplatform, introducing common interfaces for source models (such as SManga, SChapter, and Page) and catalogue operations (CatalogueSource) alongside Android-specific implementations for preferences and reactive extensions. This update expands the extension capabilities by adding new interfaces for URI resolution (ResolvableSource), page previews (PagePreviewSource), and related manga suggestions (supportsRelatedMangas), while also introducing a new AutoComplete filter type and allowing extensions to define custom metadata via a JSON memo field on manga and chapter objects.

source-api · high confidence

The Source Feed screen has been rewritten using the Voyager navigation library, replacing the previous implementation. This change introduces a new screen model (SourceFeedScreenModel) that manages state and logic, including support for incognito mode toggling, feed reordering, and bulk favorite operations. The UI now integrates with Voyager's navigator for navigation handling, allowing users to browse source feeds with improved navigation flow and state management.

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

The Source Category screen has been rewritten to use the Voyager navigation library, introducing a new screen model that manages state for creating, renaming, and deleting source categories. This change replaces the previous implementation with a Compose-based UI that handles category operations asynchronously and displays localized error messages for invalid names or internal errors.

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

The app now manages source delegation and visibility through new helper logic and a blacklist. SourceHelper.kt introduces functions to identify and group delegated sources (Pururin, EightMuses, NHentai, Lanraragi) and explicitly excludes specific sources (EH, EXH, Pururin, and NHentai instances) from automatic library updates. Additionally, BlacklistedSources.kt defines a list of blacklisted extensions and hidden sources, allowing the app to filter out or hide specific source implementations from the user interface.

app/src/main/java/exh/source · high confidence

The source management layer now initializes built-in Hentai sources (EHentai) based on the user's 'isHentaiEnabled' preference, integrating them alongside local and extension sources. Additionally, source naming logic has been refined to support Incognito mode, allowing specific extensions (including Local and EH-based sources) to be hidden from library views, and improves merged source display by correctly handling local/stub sources in the name string.

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

The Source domain model now exposes two new computed properties: \icon\, which retrieves the extension's app icon as a Compose \ImageBitmap\ via the ExtensionManager, and \installedExtension\, which allows the model to check if a corresponding extension is currently installed. This enables UI components to display source icons and determine installation status directly from the Source object without requiring external lookups.

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

The \core:archive\ module has been introduced to centralize archive handling, adding support for reading encrypted CBZ files and writing encrypted ZIPs. Users can now open password-protected archives, with the app detecting encryption status and prompting for credentials via the existing security preferences. The module also includes an \EpubReader\ for parsing EPUB structures and a \ZipWriter\ that allows creating password-protected ZIP files using AES or ZipCrypto standards based on user settings.

core/archive · high confidence

The sync module now uses a dedicated \SyncPreferences\ class to manage synchronization settings, introducing new preference keys for WebDAV configuration (URL, username, password, folder) and adding support for syncing custom info, read entries, and saved search feeds. The system also generates a unique device ID for cross-device synchronization and allows users to configure sync triggers based on chapter read/open events or app start/resume states, while maintaining backward compatibility for existing sync services like Google Drive.

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

Telemetry services (Firebase Analytics and Crashlytics) are now disabled by default and only activate in official Mihon production builds, verified by checking the app's package name against a hardcoded list of allowed packages and validating the APK's SHA-256 certificate fingerprint. This prevents forked or test builds from polluting production data. Additionally, the telemetry module's manifest explicitly removes unnecessary permissions inherited from Firebase dependencies, such as AD\_ID and install referrer access, and disables automatic ad personalization and screen reporting to minimize data collection.

telemetry · high confidence

The tracker login process has been consolidated into a single, streamlined experience. Instead of separate activities for each service, the app now uses a unified \TrackLoginActivity\ to handle authentication for AniList, Bangumi, MyAnimeList, and Shikimori, while \GoogleDriveLoginActivity\ manages its own OAuth flow. Both activities share a common base that displays a Compose-based loading screen during the redirect, ensuring a consistent visual state while the authentication code is processed, and automatically return the user to the main settings screen upon completion.

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

The recommendation browsing experience has been consolidated into dedicated screens (RecommendsScreen and BrowseRecommendsScreen) that support bulk-favorite operations. Users can now long-press or enter selection mode to add multiple recommended manga to their library at once, with visual feedback via a selection toolbar and haptic feedback. The interface also handles external sources by opening a SmartSearch configuration screen instead of a direct manga detail view, and ensures stable navigation using unique keys to prevent crashes when sources are unavailable or removed.

app/src/main/java/exh/recs · high confidence

The chapter list filtering now uses the manga's original title (ogTitle) when checking download status, which improves accuracy for sources that may have title variations. Additionally, the Chapter model conversion functions have been updated to include the scanlator field in database records and to trim empty scanlator values when copying from source chapters, ensuring cleaner data storage and retrieval.

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

The Updates tab now organizes the list of recent updates by grouping entries under their respective dates. Within each group, chapters are sorted so that unread items always appear at the top, followed by read items, ensuring the most relevant new content is immediately visible. This change is implemented in the new UpdatesScreenModel and UpdatesTab components, which handle the grouping logic and UI presentation.

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, introducing new fetchers and keyers for manga covers and page previews. This change enables a new feature where the app can extract dominant and vibrant colors from cover images to use for theming the details page, controlled by the 'theme based on cover' preference. The implementation includes a new \BufferedSourceFetcher\ for in-memory images, updated \MangaCoverFetcher\ logic to handle custom covers and library caching, and a \TachiyomiImageDecoder\ that supports additional image formats like AVIF and JXL.

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

The backup and restore process now includes a dedicated option to restore saved searches and feed configurations. This change introduces a new \savedSearchesFeeds\ toggle in the restore options, allowing users to choose whether to import these specific items during a partial restore. The underlying restore logic has been updated to handle the restoration of saved searches and feed data independently, ensuring they are processed correctly alongside library entries, categories, and app settings.

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

The in-app WebView has been rewritten using Jetpack Compose and the Voyager navigation library, replacing the previous implementation. This change introduces a new screen model for managing state and logic, adds support for Android's Assist Content API to allow sharing URLs via system assistants, and integrates Discord Rich Presence to display the current screen context. Users will experience a modernized UI for web content, improved stability when handling source headers, and new system-level integration features.

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

The WebView screen has been completely rewritten using Jetpack Compose, replacing the previous implementation. This change introduces native multi-window support, allowing users to open new tabs or popups within the app instead of redirecting to an external browser. The new screen also includes improved handling for Cloudflare captcha pages by displaying a help banner, ignores potentially dangerous 'intent://' URLs, and directly tracks the current URL for better state management.

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

The Shizuku-based extension installer now correctly handles the installation of extension updates. A new \ShellInterface\ implementation ensures that when an extension is installed or updated via Shizuku, the process properly writes the APK data and commits the session, resolving issues where installed extensions were not being updated correctly.

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

The Migrate Manga dialog now correctly reappears when triggered multiple times from the same screen, resolving a bug where it would fail to show on subsequent attempts. Additionally, the migration process now accurately targets the correct entry, preventing data from being migrated to the wrong manga record.

app/src/main/java/mihon/feature/migration/dialog · medium confidence

Added DummyTracker test stub; Added tests for local favorites storage synchronization logic; Added unit tests for the application migration logic; Removed legacy Robolectric unit tests and configuration.

The project is initialized with a new Gradle build structure, including root and app-level build scripts and a buildSrc module for shared configuration. This establishes the foundational build environment, defining application metadata (version 1.14.1), build variants (debug, release, foss, preview, benchmark), and core dependencies such as Kotlin serialization, AboutLibraries, and Firebase Crashlytics.

(dependencies) · high confidence

The project's Gradle wrapper has been updated from version 2.2.1 to 9.3.1. This change updates the distribution URL to fetch Gradle 9.3.1 and introduces new configuration properties, specifically a 10-second network timeout and distribution URL validation, to improve build reliability and security.

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 43 → 46 (+2.5)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 84 → 86 (+2.3)
• Architecture 94 → 90 (-4.0)
• Maturity 44 → 62 (+18.0)
• Readiness 32 → 40 (+7.6)
• Security 38 → 31 (-7.1)
• 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/browse/FeedScreen.kt)
• Duplicated block (10 lines × 2) (app/src/main/java/eu/kanade/presentation/components/Chip.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/reader/ReaderViewModel.kt)
• Duplicated block (10 lines × 2) (data/src/main/java/tachiyomi/data/manga/MangaMergeRepositoryImpl.kt)
• Duplicated block (10 lines × 2) (presentation-core/src/main/java/tachiyomi/presentation/core/components/VerticalFastScroller.kt)
• Duplicated block (10 lines × 7) (app/src/main/java/exh/md/handlers/FilterHandler.kt)
• Duplicated block (11 lines × 2) (app/src/main/java/eu/kanade/presentation/manga/MangaScreen.kt)
• Duplicated block (11 lines × 2) (app/src/main/java/eu/kanade/presentation/manga/components/MangaBottomActionMenu.kt)
• Duplicated block (11 lines × 2) (app/src/main/java/eu/kanade/tachiyomi/data/sync/service/GoogleDriveSyncService.kt)
• Duplicated block (12 lines × 2) (app/src/main/java/eu/kanade/presentation/more/onboarding/PermissionStep.kt)
• Duplicated block (12 lines × 2) (app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsAppearanceScreen.kt)
• Duplicated block (12 lines × 2) (app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsReaderScreen.kt)
• Duplicated block (12 lines × 2) (app/src/main/java/eu/kanade/tachiyomi/ui/manga/merged/EditMergedSettingsDialog.kt)
• Duplicated block (13 lines × 2) (app/src/main/java/eu/kanade/presentation/browse/components/SourceFeedDialogs.kt)
• Duplicated block (13 lines × 2) (core/common/src/main/kotlin/tachiyomi/core/common/util/system/UrlUtils.kt)
• Duplicated block (13 lines × 2) (presentation-core/src/main/java/tachiyomi/presentation/core/components/VerticalFastScroller.kt)
• Duplicated block (13 lines × 2) (source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/source/online/UrlImportableSource.kt)
• …and 85 more

• AppLanguageScreen.getLangs (cognitive 16) (app/src/main/java/eu/kanade/presentation/more/settings/screen/appearance/AppLanguageScreen.kt)
• Boundary-crossing change coupling: MainActivity.kt ↔ CrashlyticsPrinter.kt (app/src/main/java/eu/kanade/tachiyomi/ui/main/MainActivity.kt)
• BrowseSourceEHentaiListKt.BrowseSourceEHentaiListItem (cyclomatic 21) (app/src/main/java/eu/kanade/presentation/browse/components/BrowseSourceEHentaiList.kt)
• BrowseSourceScreen.Content (cognitive 31) (app/src/main/java/eu/kanade/tachiyomi/ui/browse/source/browse/BrowseSourceScreen.kt)
• BrowseSourceScreen.Content (cyclomatic 32) (app/src/main/java/eu/kanade/tachiyomi/ui/browse/source/browse/BrowseSourceScreen.kt)
• BrowseSourceScreenKt.BrowseSourceContent (cognitive 22) (app/src/main/java/eu/kanade/presentation/browse/BrowseSourceScreen.kt)
• BrowseSourceScreenKt.BrowseSourceContent (cyclomatic 20) (app/src/main/java/eu/kanade/presentation/browse/BrowseSourceScreen.kt)
• BrowseSourceScreenModel.searchGenre (cognitive 23) (app/src/main/java/eu/kanade/tachiyomi/ui/browse/source/browse/BrowseSourceScreenModel.kt)
• ButtonElevation.animateElevation (cyclomatic 16) (presentation-core/src/main/java/tachiyomi/presentation/core/components/material/Button.kt)
• Change coupling: Banners.kt ↔ MainActivity.kt (app/src/main/java/eu/kanade/presentation/components/Banners.kt)
• Change coupling: BrowseSourceScreenModel.kt ↔ NetworkToLocalManga.kt (app/src/main/java/eu/kanade/tachiyomi/ui/browse/source/browse/BrowseSourceScreenModel.kt)
• Change coupling: BrowseSourceSimpleToolbar.kt ↔ MigrateSourceSearchScreen.kt (app/src/main/java/eu/kanade/presentation/browse/components/BrowseSourceSimpleToolbar.kt)
• Change coupling: DuplicateMangaDialog.kt ↔ MangaDexFollowsScreen.kt (app/src/main/java/eu/kanade/presentation/manga/DuplicateMangaDialog.kt)
• Change coupling: GlobalSearchScreen.kt ↔ GlobalSearchScreenModel.kt (app/src/main/java/eu/kanade/presentation/browse/GlobalSearchScreen.kt)
• Change coupling: GlobalSearchScreen.kt ↔ GlobalSearchToolbar.kt (app/src/main/java/eu/kanade/presentation/browse/GlobalSearchScreen.kt)
• Change coupling: HistoryScreen.kt ↔ HistoryItem.kt (app/src/main/java/eu/kanade/presentation/history/HistoryScreen.kt)
• Change coupling: MigrateSearchScreen.kt ↔ GlobalSearchScreen.kt (app/src/main/java/eu/kanade/tachiyomi/ui/browse/migration/search/MigrateSearchScreen.kt)
• Change coupling: MigrateSearchScreen.kt ↔ GlobalSearchScreenModel.kt (app/src/main/java/eu/kanade/tachiyomi/ui/browse/migration/search/MigrateSearchScreen.kt)
• Change coupling: MigrateSearchScreen.kt ↔ GlobalSearchToolbar.kt (app/src/main/java/eu/kanade/presentation/browse/MigrateSearchScreen.kt)
• Change coupling: MigrateSourceSearchScreen.kt ↔ MangaDexFollowsScreen.kt (app/src/main/java/eu/kanade/tachiyomi/ui/browse/migration/search/MigrateSourceSearchScreen.kt)
• …and 443 more

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

komikku-app/komikku 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.