mihonapp/mihon

This system is a manga and comic reader application that manages a local library of content sourced from various extensions and trackers. It provides capabilities for browsing, downloading, and reading manga, with features for tracking progress across multiple external services and organizing content into customizable categories. The application handles complex data synchronization, backup and restore operations, and offers a modern, composable user interface for managing reading habits and settings.

56 changes.

This period focused on a comprehensive modernization of the codebase, migrating the application from legacy Java and RxJava patterns to Kotlin, Jetpack Compose, and Kotlin Coroutines. It involved replacing outdated dependency injection and data persistence systems with modern alternatives like Metro DI, WorkManager, and protobuf-based backups. The work also included significant UI overhauls, tracker API updates, and the introduction of new features such as biometric authentication and advanced image format support.

60 changes.

This period focused on the comprehensive migration of the application's user interface from the legacy View system to Jetpack Compose, accompanied by a visual overhaul to Material 3 design principles. The work involved rewriting core screens such as the library, browse, settings, and reader, while simultaneously refactoring the underlying domain layer to support reactive state management and new features like MangaUpdates tracking and crash recovery.

63 changes.

This period focused on migrating the data layer to SQLDelight and restructuring the application architecture around the Metro dependency injection framework. Simultaneously, the user interface was comprehensively rewritten using Jetpack Compose and Material 3, replacing legacy Android views with modern, reusable components. These foundational changes enabled new features such as granular backup controls, a guided onboarding flow, and an upcoming releases tracker.

27 changes.

This period focused on a comprehensive redesign of the manga migration system, introducing selective data transfer, mass migration capabilities, and refined configuration options. Concurrently, the project modernized its technical foundation by migrating dependency injection to Metro, rewriting Gradle build logic, and implementing WebGPU-based rendering for improved reader performance.

The core-metadata module now includes support for reading and writing ComicInfo.xml metadata files, allowing users to automatically convert details.json to ComicInfo.xml for local series. This change introduces new fields for Year, Month, Day, and chapter numbers in ComicInfo, and better handles decimal chapter numbers and categories. Additionally, a new MangaDetails model is added to represent manga metadata including title, author, artist, description, genre, and status.

core-metadata/src/main/java · high confidence

A new Kotlin file in the domain source model package provides a suspend function to retrieve a source's icon as a Compose ImageBitmap. This utility bridges the existing source model with the UI layer by fetching the app icon via the dependency injection graph and converting it to a format suitable for Jetpack Compose, replacing or supplementing previous bitmap handling mechanisms.

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

Users can now sync their manga tracking data with the Hikka service. This new integration allows users to log in via OAuth, search for manga (including by ID), update reading progress and scores, and manage their reading status (Reading, Completed, Plan to Read, etc.) directly within the app.

app/src/main/java/eu/kanade/tachiyomi/data/track/hikka, app/src/main/java/eu/kanade/tachiyomi/data/track/hikka/dto, app/src/main/java/eu/kanade/tachiyomi/data/track/mangabaka · high confidence

Users can now track manga with the MangaUpdates service. This change introduces the core integration logic, including API communication for searching, updating reading lists (reading, complete, on-hold, unfinished, wish), managing scores, and handling authentication via session tokens.

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

The app now includes the AIDL interface definition for Shizuku's shell service, exposing methods to install APKs via an AssetFileDescriptor and IntentSender, and to destroy the session. This enables the application to communicate with Shizuku for privileged installation tasks.

app/src/main/aidl · high confidence

Users can now sync their reading progress with a Suwayomi server. This change introduces the Suwayomi tracker implementation, which communicates via the server's GraphQL API to update reading status, refresh metadata, and optionally delete downloaded chapters on the server based on extension settings.

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

A new CrashScreen UI has been added to handle application crashes gracefully. When a crash occurs, users are presented with an InfoScreen displaying the exception details and offering two actions: dumping the crash logs for debugging or restarting the application. This screen integrates with the app's dependency injection to access the crash log utility and uses localized strings for all user-facing text.

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

The app now includes a dedicated CrashActivity and GlobalExceptionHandler to manage uncaught exceptions. When a fatal error occurs, the GlobalExceptionHandler logs the error, serializes the exception details, and launches the CrashActivity, which displays a CrashScreen UI allowing the user to restart the app. This ensures that crashes are handled gracefully with a user-facing screen rather than an abrupt force-close, while still passing the exception to the default system handler for logging purposes.

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

Users can now search for manga to migrate from other sources directly within the migration flow. The new MigrateSearchScreen allows searching across enabled migration sources with pre-filled queries based on the source manga, while MigrateSourceSearchScreen enables browsing and filtering within a specific source during migration. Both screens support selecting target manga and initiating the migration process through the existing dialog system.

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

A new stats screen has been introduced to display user reading habits and library statistics. The screen presents an overview section showing the number of manga in the library, total read duration, and completed titles. It also breaks down statistics by titles (including those in global updates, started, and local), chapters (total, read, and downloaded), and tracker integration (tracked titles, mean score, and number of used trackers).

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

Users can now export a 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 Advanced settings screen now includes a new 'Clear Database' interface that allows users to selectively remove manga entries. When confirming the deletion, users can toggle a switch to exclude read manga from the removal process, providing more control over database cleanup compared to a full wipe.

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

A new statistics screen has been added, allowing users to view an overview of their library including total manga count, completed titles, total read duration, global update items, local manga count, chapter statistics, and tracker information such as mean scores and logged-in tracker counts. The screen displays a loading state while data is fetched and then presents the calculated stats using the new presentation components.

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

The presentation-core module now includes new theme extension properties that simplify styling. An \active\ color extension on \ColorScheme\ provides a yellow shade that adapts to the system's dark or light mode, while a \header\ extension on \Typography\ defines a semi-bold, variant-colored text style for headers.

presentation-core/src/main/java/tachiyomi/presentation/core/theme · high confidence

Users can now add and edit notes for individual manga entries. This change introduces the MangaNotesScreen, which allows users to view and update notes associated with a specific manga title. The feature is implemented using a ViewModel that manages the note state and persists changes to the database via the UpdateMangaNotes interactor.

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

The design system now includes utility functions to detect screen width categories, enabling UI components to adapt to different device sizes. New composables \isMediumWidthWindow()\ and \isExpandedWidthWindow()\ allow developers to check if the current window width exceeds 600dp or 840dp respectively, facilitating responsive layout adjustments in the application.

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

The baseline-profile module now includes the necessary components to generate and measure Android Baseline Profiles. This adds a BaselineProfileGenerator that simulates user interactions (Updates, History, Browse, Extensions, More) to create optimized profiles, a StartupProfileGenerator for cold-start optimization, and a suite of startup benchmarks (Cold, Warm, Hot) to measure performance improvements. These changes enable the app to leverage baseline profiles for faster startup times and improved runtime performance.

baseline-profile · high confidence

A new utility function, collectAsLazyPagingItems, has been added to the presentation-core module. This Composable helper simplifies the process of observing and displaying paginated data streams within Jetpack Compose UIs by correctly handling the nested StateFlow structure, ensuring that paging data is properly collected and rendered in lazy lists.

presentation-core/src/main/java/mihon · high confidence

The AniList integration has been updated to support tracking start and finish dates, allowing users to see when they began or completed a series. Additionally, the tracker now supports private tracking, enabling users to keep their reading history hidden from public view on the AniList platform.

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

The app now features a dedicated DeepLinkScreen and DeepLinkViewModel that process incoming URIs to identify and navigate to specific content. When a user opens a link, the system queries available sources to resolve the URL into a manga or a specific chapter. If a chapter is identified, the reader opens directly to that chapter; if only a manga is found, the user is taken to the manga details screen; and if no results are found, the query is passed to the global search. This replaces the previous behavior where deep links might have simply triggered a generic search or opened the main activity without specific content resolution.

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

The domain module has been reorganized to centralize core business logic, introducing dedicated interactor classes for managing categories (create, delete, rename, reorder), chapters (filtering for download, bookmark retrieval, sorting, and recognition), and extension stores (adding, removing, and listing stores). A new AST-based library search feature has been added, allowing users to filter their library using complex queries with operators like AND, OR, and NOT, as well as field-specific comparisons (e.g., title, genre, status). Additionally, the app now supports content warnings for extensions, replacing the previous NSFW flag system, and introduces an 'Upcoming' page to track manga with ongoing or recently finished statuses.

domain/src/main · high confidence

The global search screen now allows users to restrict search results to a specific extension. This is implemented via a new \GlobalSearchScreen\ and \GlobalSearchViewModel\ that accept an \extensionFilter\ parameter, enabling the UI to pass this filter to the backend logic which then limits the search scope to sources belonging to that specific extension package.

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

Added Kotlin data classes (MALList, MALManga, MALOAuth, MALSearch, MALUser) to the MyAnimeList tracking module to structure API responses using kotlinx.serialization. These DTOs map fields such as manga metadata, search results, user info, and OAuth tokens, enabling the app to correctly parse and handle data from the MyAnimeList API, including handling nullable fields like cover images and author information.

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

A new \SharedPreferencesDataStore\ class has been added to bridge Android's \SharedPreferences\ with the AndroidX \PreferenceDataStore\ interface. This allows UI preference screens to read and write settings directly to shared preferences using standard AndroidX components, simplifying how user preferences are managed and displayed in the app.

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

Adds the UI components for the new Upcoming page, including a vertical grid calendar that displays monthly release events with animated month navigation and day indicators, alongside a list item component that displays manga covers and titles for upcoming releases.

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

A new Upcoming screen has been added to the app, allowing users to view manga releases by date using a calendar interface. This feature includes category filters (accessible via a dialog) to include or exclude specific categories from the view, and displays a quantity badge next to each date header indicating the number of upcoming releases for that day.

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

The app now includes a new WebGPU-powered reader viewer that replaces the legacy decoder with a high-quality renderer. This change brings improved image rendering capabilities, fixes for GPU texture leaks, and better handling of animated images and navigation in long strips, while maintaining compatibility with existing reader preferences and navigation modes.

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

The app now includes a new More tab that serves as the central hub for settings, categories, stats, and a new 'Support Us' screen. A dedicated New Update screen allows users to download and install app updates directly within the app, replacing the previous system-level update flow. Additionally, a new Onboarding screen guides new users through initial setup, preventing accidental exit until completion and offering a direct path to restore backups.

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

A new \Download\ data class has been added to the application's data layer to represent the state of a single chapter download. This model encapsulates the associated \Manga\, \Chapter\, and \HttpSource\, and provides properties and flows to track download progress, total images downloaded, and the current state (e.g., not downloaded, queued, downloading, downloaded, or error). It utilizes Kotlin Coroutines \StateFlow\ to expose real-time status updates to the UI.

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

The pager-based reader now uses a new implementation located in the pager viewer package. This includes a custom Pager view for handling touch gestures, a PagerConfig class to manage reader preferences like navigation mode and image scaling, and dedicated page and transition holders for displaying content. The PagerViewer base class and its adapters handle the lifecycle and page management for Left-to-Right, Right-to-Left, and Vertical reading directions.

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

A new DelayedTrackingStore has been added to the domain layer to manage a local queue of tracking updates. This component stores pending chapter progress changes in private shared preferences, allowing the app to batch or defer synchronization with external tracking services. This supports the broader migration to the Metro dependency injection framework and aims to improve reliability by ensuring tracking data is refreshed before updates are applied.

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

The app's color schemes have been migrated from XML to Compose, introducing a new BaseColorScheme architecture that supports an AMOLED mode for deeper blacks. This change adds several new visual themes including Catppuccin, Lavender, Monet (dynamic colors), Monochrome, Strawberry, Tako, Teal Turquoise, Tidal Wave, Tokyo Night, and Yin & Yang, while also updating the default Tachiyomi theme.

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

The migration list screen now includes dedicated UI components for managing the migration workflow: a dialog to confirm exiting the migration process, a dialog to review and confirm the migration (or copy) of selected manga including skipped items, and a progress dialog with an animated linear indicator that prevents accidental dismissal. Additionally, a new MigratingManga model class manages the per-manga migration state, tracking search results (searching, not found, or success) within a dedicated coroutine scope.

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

A dedicated "Support Us" screen has been added to the app, allowing users to view information about support perks and easily access donation platforms (Patreon, Open Collective) and community channels (Discord) via direct links.

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

The app now provides direct integration between the core preference system and Jetpack Compose. A new \PreferenceMutableState\ class and \asState\ extension allow preferences to be observed and modified as Compose \MutableState\, automatically syncing changes via coroutine flows. Additionally, a helper converts tri-state checkbox preferences into Compose \ToggleableState\ for UI binding.

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

The presentation-core module now includes a suite of new Material 3 UI components, providing a standardized set of building blocks for the app's interface. This addition introduces custom implementations for common controls including AlertDialog, Button, IconButton, IconToggleButton, PullRefresh, Scaffold, Slider, Surface, and Tabs. These components are designed to ensure consistent styling and behavior across the application, leveraging the latest Material 3 specifications for layout, color, and interaction.

presentation-core/src/main/java/tachiyomi/presentation/core/components/material · high confidence

The data module now includes a new database adapter and query extensions that integrate SQLDelight with Kotlin coroutines and AndroidX Paging. This adds column adapters for serializing dates, string lists, update strategies, and JSON objects, along with extension functions to stream query results as Flows and a PagingSource implementation for efficient database-backed list paging.

data/src/main/java/tachiyomi/data · high confidence

A new TrackSearch data class has been introduced to support richer search results from trackers. This model extends the base Track interface and adds fields for author and artist lists, cover images, summaries, and publishing details (status and type), enabling the UI to display more comprehensive information such as staff credits and average scores during search operations.

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

The app now includes a new Updates Grid widget available for both the home screen and the lock screen (including Samsung Galaxy Z Flip cover screens). 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 security settings by showing a locked placeholder when the app lock is enabled, and it uses Coil3 for image loading with proper caching and rounding. The widget is configurable in size and updates automatically when new chapters are downloaded.

presentation-widget · high confidence

A new AppLanguageScreen has been added to the appearance settings, allowing users to select the application language from a list parsed from the locales configuration. This screen displays both the localized display name and the non-localized (English) name for each language option, improving clarity when choosing languages. The selection is applied immediately via AppCompatDelegate.

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

A new UnlockActivity has been introduced to handle app unlocking via biometric prompts. This activity initializes the authentication flow using the AuthenticatorUtil, displaying a dialog that includes the app name. Upon successful authentication, it triggers the SecureActivityDelegate to unlock the app and then finishes the activity; errors result in logging and closing the app.

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

The reader interface now includes a new ChapterNavigator component that supports both horizontal and vertical slider orientations, allowing users to quickly jump between pages or chapters with haptic feedback and adaptive padding for tablet UIs. Additionally, a ModeSelectionDialog component has been added to reading mode and orientation settings, providing distinct Apply and Revert to Default buttons for clearer control over reader preferences.

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

Added CollectionUtils.kt with new extension functions for Kotlin collections, including insertSeparators and insertSeparatorsReversed for inserting separators between list elements, addOrRemove for conditional HashSet updates, and fastFilterNot, fastPartition, and fastCountNot for optimized filtering and partitioning operations on random-access lists.

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

A new \:core:archive\ module has been introduced, providing low-level utilities for handling compressed files. This includes an \ArchiveReader\ and \ArchiveInputStream\ that leverage the \libarchive\ library to read various archive formats via memory-mapped file descriptors, as well as an \EpubReader\ that parses EPUB structures to extract page and image paths. The module also adds a \ZipWriter\ for creating ZIP archives and Kotlin extensions to easily obtain readers from \UniFile\ objects, enabling the application to load local source EPUB files and manage archive content more efficiently.

core/archive · high confidence

The app now includes a new CrashLogUtil that generates a detailed debug report (app version, device info, WebView version, and problematic extension status) and directly shares the log file via the system share sheet instead of posting a notification. Additionally, new utility files provide PKCE code generation for secure authentication flows and helper functions for managing manga cover caching and local cover updates.

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

The Debug Info screen now includes two new entries: 'Backup file schema', which displays the Protobuf schema of backup files and allows copying it to the clipboard, and 'Worker info', which shows the status of background work tasks (enqueued, running, finished) with details like next scheduled run times, also copyable. These additions provide users with more detailed diagnostic information directly within the app's debug settings.

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

The app introduces four new domain-layer interactors in the manga module to handle specific data operations. GetExcludedScanlators and SetExcludedScanlators allow users to manage lists of scanlators to exclude from updates for specific manga titles. SetMangaViewerFlags enables the persistence of reading mode and orientation preferences per manga item. UpdateManga centralizes various manga metadata updates, including fetch intervals, last update timestamps, cover modification dates, and favorite status changes.

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

Added FileExtensions.kt and OkioExtensions.kt to the storage utilities, introducing helper functions for managing local files. FileExtensions.kt provides a method to copy files while explicitly setting them as read-only to prevent modification, along with URI generation for sharing via FileProvider. OkioExtensions.kt adds safe saving capabilities for BufferedSource objects, ensuring that parent directories are created as needed and resources are properly closed even if errors occur during the write process.

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

The app now presents a multi-step onboarding screen upon first launch, guiding users through initial setup. The flow includes a theme selection step to configure appearance, a storage step to choose the app's data directory, a permission step to request necessary system permissions (such as notifications and battery optimization) and configure telemetry preferences, and a guides step that provides links to getting started documentation and backup restoration. This replaces the previous immediate entry into the app, ensuring users are oriented and configured correctly from the start.

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

The history screen now features new UI components: HistoryItem displays manga history entries with a cover, title, chapter number, and read time, and includes a new button to add the manga to favorites. HistoryDialogs introduces two confirmation dialogs for deleting history: one for removing a single entry (with an option to reset reading progress) and one for clearing all history. These components are supported by a preview parameter provider for design-time testing.

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

This change introduces new utility files in the language support package to improve how the app handles dates and resources. DateExtensions.kt provides functions for formatting timestamps and converting relative dates (e.g., "Today", "3 days ago") using modern Kotlin datetime APIs, ensuring consistent and localized date displays. CloseableExtensions.kt adds a safe extension for managing Closeable resources, ensuring proper cleanup even when exceptions occur. RectFExtensions.kt introduces a helper to invert screen coordinates based on reader tapping settings, supporting accessibility and navigation preferences.

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

A new migration dialog has been introduced for the manga feature, allowing users to choose specific data types (such as chapters, categories, notes, and custom covers) to migrate from a source manga to a target. The dialog provides distinct actions to either copy the selected data without replacing the target or migrate and replace the target's content, while also offering an option to view the manga details before proceeding.

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

Users can now select specific manga titles to migrate from a source. This new screen lists the source's favorites, allows multi-selection via a toggle mode, and provides a button to proceed to the migration configuration screen where target sources can be chosen.

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

Added the UpdateMangaFromRemote interactor and the RemoteMangaUpdate model to the source domain layer. The interactor handles fetching manga details and chapters from remote sources, updating local database records (including title, cover, and metadata), and returning a structured result containing the updated manga and any newly discovered chapters.

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

A new Mass Migration screen has been added, allowing users to select specific manga from their library and migrate them to new sources. The screen displays a list of selected items, automatically searches for matches across configured sources, and provides options to migrate, copy, or skip individual entries. It includes UI components for progress tracking, manual search, and confirmation dialogs, replacing the previous workaround-based implementation with a dedicated, robust migration flow.

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

The app introduces a suite of new Compose UI components in the presentation layer to standardize and improve the user interface. AdaptiveSheet provides a dialog-based sheet that adapts its layout for tablets versus phones, while AppBar and AppBarTitle offer a consistent top app bar with support for action modes and marquee text for long titles. TabbedScreen and TabbedDialog enable tabbed navigation with integrated search toolbars and snackbar support, and DownloadDropdownMenu adds specific download options (including bookmarked chapters) to the user workflow. Additional components like Banners for app state indicators, DateText for localized relative dates, and DropdownMenu enhancements (overlapping anchors, nested menus) further refine the visual consistency and usability of the application.

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

This change introduces a new set of utility files in the presentation-core module to standardize common UI patterns. It adds Elevation.kt for animating component elevation based on interaction states (press, drag, hover, focus), and Scrollbar.kt to provide composable modifiers for drawing horizontal and vertical scrollbars on LazyLists, including fixes for empty lists and sticky headers. Additionally, it provides Modifier extensions for handling soft keyboard visibility (showing/hiding and clearing focus), physical Enter key events, and selection styling, alongside helper functions for combining PaddingValues and collecting Preference states as Compose State objects.

presentation-core/src/main/java/tachiyomi/presentation/core/util · high confidence

The reader module now includes a new set of model classes to manage reading state and transitions. ReaderChapter tracks the loading state of chapters (Wait, Loading, Error, Loaded) and handles reference counting for memory management. ReaderPage extends the base Page model to include chapter references and stream access. ChapterTransition defines navigation between chapters with custom equality logic. InsertPage handles special page insertion logic, and ViewerChapters manages the set of chapters currently held in memory for the viewer.

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

The reader now supports multiple tap-zone configurations, including a new 'Disabled' layout that turns off navigation entirely, as well as 'Edge', 'Kindlish', 'L', and 'Right and Left' layouts that define specific screen regions for previous/next page navigation and menu access.

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

The presentation-core module now includes a suite of new Compose components to standardize the app's interface. This adds an ActionButton for icon-and-label actions, an AdaptiveSheet that renders as a centered dialog on tablets and a draggable bottom sheet on phones, and a CombinedCircularProgressIndicator that rotates during determinate progress to indicate activity. Settings management is enhanced with a LabeledCheckbox, a WheelPicker supporting manual text input and haptic feedback, and a comprehensive SettingsItems file containing Heading, Icon, Sort, Checkbox, Radio, and Slider items. Layout and navigation utilities include LazyColumn and LazyGrid wrappers with fast scrollers, a LazyColumnWithAction for lists with a bottom button, a TwoPanelBox for split-screen layouts, a CollapsibleBox for expandable sections, a SectionCard, a BadgeGroup for grouped badges, a Pill for small labels, a LinkIcon for URL shortcuts, and a ListGroupHeader.

presentation-core/src/main/java/tachiyomi/presentation/core/components · high confidence

The presentation-core module now includes three new Compose UI components: EmptyScreen, InfoScreen, and LoadingScreen. EmptyScreen displays a random kaomoji face and a message, with support for scrollable content and action buttons, and ensures correct rendering of kaomoji in RTL locales by forcing LTR layout direction. InfoScreen provides a scaffolded layout with a header, icon, and customizable accept/reject action buttons at the bottom. LoadingScreen offers a simple centered progress indicator. These components standardize common UI patterns across the application.

presentation-core/src/main/java/tachiyomi/presentation/core/screens · high confidence

A new \TrackLogoIcon\ composable has been added to the track presentation components, providing a standardized way to display tracker logos with rounded corners and a fixed size. This component supports both click and long-press interactions, enabling future features like copying tracker URLs via long press, and includes preview support for development.

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

Added a new Compose UI component (StatsItem.kt) that renders individual statistics items with a title, subtitle, and optional icon, using Material 3 typography and theming for the stats screen.

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

The app introduces a new set of utility classes in the system package to standardize and simplify access to device capabilities. This includes AnimationExtensions for reading the system animation scale, AuthenticatorUtil for handling biometric and device credential authentication, and BuildConfig helpers to identify build variants (debug, nightly, release, FOSS). ContextExtensions provide convenient methods for clipboard operations, opening browsers, managing reader theme contexts, and checking package installation status. DeviceUtilExtensions now detect dynamic color availability, while DisplayExtensions handle tablet UI thresholds and night mode detection. IntentExtensions standardize sharing and parcelable retrieval, NetworkExtensions and NetworkStateTracker manage connectivity checks and state flows, NotificationExtensions simplify notification posting and channel creation, and WorkManagerExtensions ensure workers run safely in a foreground service context.

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

The app introduces new Kotlin extension functions in the view utilities package to simplify common UI patterns. Developers can now use \setComposeContent\ on Activities and ComposeViews to automatically apply the app's theme and Metro dependency injection context, ensuring consistent styling and state management. A new \popupMenu\ extension allows for easier creation of popup menus with custom click handlers, and a \setSecureScreen\ function enables toggling the secure flag on windows (useful for features like incognito mode). Additionally, a helper function \isVisibleOnScreen\ checks if a view is currently visible on the device screen.

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

The reader viewer's UI components, including the progress indicator, chapter transition view, and page image wrapper, have been rewritten using Jetpack Compose. This change modernizes the reader interface, improves consistency with the rest of the app's UI, and simplifies state management for loading states and chapter transitions.

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

The tracker interface has been rebuilt using new Compose-based components, introducing support for private tracking on compatible services like AniList and Bangumi. Users can now toggle privacy for tracked items, copy tracker URLs via long-press, and view staff information in search results. The update also includes a new date picker for reading dates, improved search result previews, and a context menu for copying or opening tracker links in a browser.

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

The repository has been initialized with the core project structure, including the Apache 2.0 license, a comprehensive changelog, and contributor guidelines. The README has been updated to reflect the Mihon branding, features, and download links. Build infrastructure is established with a new .editorconfig for code style consistency, a .gitattributes file to manage line endings and binary files, and an updated .gitignore. The Travis CI configuration has been removed, and the Gradle wrapper scripts have been updated to the latest standard format with the shell script made executable.

(repo-wide) · high confidence

The Updates tab now allows users to filter the list of recent updates by specific categories. This is implemented via a new \UpdatesSettingsViewModel\ that manages included and excluded category preferences, and an \UpdatesFilterDialog\ in the UI that lets users toggle these filters. The \UpdatesViewModel\ now subscribes to these category preferences and passes them to the underlying data layer, ensuring the displayed updates respect the user's category selections.

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

The legacy \Manga\ data entity, which previously handled local 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 model for manga records.

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

The legacy BaseActivity and MainActivity classes have been removed from the application. This cleanup eliminates the previous implementation that relied on the Nucleus MVP framework and Butter Knife view binding, marking the end of that specific architectural pattern in the activity layer.

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

The legacy DatabaseHelper, DbOpenHelper, and PreferencesHelper classes have been removed from the application. This eliminates the previous direct integration with the SQLite database (mangafeed.db) and the shared preferences file (android\_boilerplate\_pref\_file), indicating a shift in how data persistence and user settings are managed within the app.

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

The legacy database schema definitions for \categories\, \chapters\, \mangas\, and the \mangas\_categories\ junction table have been removed from the application. This cleanup eliminates the hardcoded SQL table creation logic and column constants that were previously used to manage local storage for manga metadata and reading status.

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

The \DetailHolder\ class, which previously rendered individual detail items in the list and handled click-to-open URL actions, has been removed from the application. This eliminates the specific UI component responsible for displaying detail text and launching external links via the \item\_detail\ layout.

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

The app has removed several utility classes from the \util\ package that were no longer in use, including \AndroidComponentUtil\, \DataUtils\, \DialogFactory\, \NetworkUtil\, \SnackbarFactory\, and \ViewUtils\. This cleanup reduces the codebase size and maintenance overhead without impacting user-facing functionality.

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

The Local Source implementation has been extracted into its own dedicated module (source-local). This change includes the creation of the module's AndroidManifest, the main LocalSource class, and supporting components such as the LocalCoverManager, LocalSourceFileSystem, and metadata readers for ComicInfo and EPUB files. This modularization isolates the local source logic from the rest of the application.

source-local · high confidence

The manga data access layer has been restructured to use a new \MangaRepositoryImpl\ and \MangaMapper\. This change introduces explicit mapping logic for \Manga\, \LibraryManga\, and \MangaWithChapterCount\ models, ensuring that library views now correctly expose total chapter counts and category associations. The repository implementation leverages SQLDelight async queries and Metro dependency injection, providing a cleaner separation of concerns for fetching manga data, handling updates, and managing category assignments.

data/src/main/java/tachiyomi/data/manga · high confidence

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

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

The Webtoon viewer implementation has been restructured into a set of dedicated classes (WebtoonViewer, WebtoonAdapter, WebtoonRecyclerView, WebtoonFrame, WebtoonConfig, and associated holders) to improve code organization and maintainability. This change introduces a custom RecyclerView layout manager with extra layout space for smoother scrolling, a dedicated frame layout to handle touch event translation during zooming, and a configuration class that binds reader preferences (such as navigation mode, side padding, and zoom settings) to the viewer's behavior. The adapter now uses DiffUtil for efficient list updates and handles chapter transitions and page loading within its own scope.

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

The About screen now features a redesigned layout using Material 3 components, including a dedicated LogoHeader and updated social media links (Discord, X, Facebook) pointing to the Mihon brand. The 'Check for Updates' and 'What's new' options are conditionally displayed based on build type and updater availability. The Open Source Licenses screen has been updated to use the Material 3 version of AboutLibraries, providing a sheet-based detail view for library information.

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

The app now uses specific data classes to parse AniList API responses, replacing previous parsing logic. This change introduces support for private tracking entries, ensuring that the privacy setting of a list item is correctly preserved in the local database. Additionally, search results now display staff information (authors and artists) and correctly identify the publishing type (Manga, Manhwa, Manhua) based on the country of origin.

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

The application entry point (App.kt) has been rewritten to use the new Metro dependency injection graph, initializing the Injekt scope, setting up TLS 1.3 support for older Android versions, configuring the new Logcat logging system, and managing Incognito Mode notifications. Additionally, a new AppInfo.kt file exposes the host application'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 monolithic backup creation process has been refactored into distinct, single-responsibility classes (CategoriesBackupCreator, ExtensionStoresBackupCreator, MangaBackupCreator, PreferenceBackupCreator, and SourcesBackupCreator). This change improves the modularity and maintainability of the backup feature by separating concerns for different data types, such as manga metadata, categories, source preferences, and extension stores, while introducing support for including private preferences in backups and filtering out empty source preferences.

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

The backup creation process has been refactored to allow users to choose exactly which data to include in a backup. The new \BackupOptions\ model introduces distinct toggles for library entries, categories, chapters, tracking, history, non-library read entries, app settings, extension stores, and source settings. Additionally, a new 'private settings' option allows users to include sensitive preference data, which is now explicitly opt-in. The system also enforces that at least one major category (library, categories, app settings, extension stores, or source settings) must be selected to create a backup, preventing empty files.

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

Users can now choose exactly which parts of a backup to restore instead of restoring everything at once. The restore process respects granular options for library entries, categories, app settings, extension stores, and source settings, allowing for partial restores. This change also introduces a background job for the restore operation and invalidates the download cache after restoring library entries to ensure the UI reflects the latest state.

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

The Bangumi tracker implementation has been rewritten to use the Bangumi v0 API, introducing support for private tracking and OAuth-based authentication. Users can now search for manga by ID using the 'id:' prefix, view average scores in search results, and refresh their profile information. The tracker automatically sets the status to completed when the last chapter is read and handles token refreshes to prevent login expiration issues.

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

The Browse, Extensions, Sources, and Search screens have been rewritten in Jetpack Compose, replacing the previous XML-based implementations. This migration introduces a consistent Material 3 design across the app, including updated pull-to-refresh indicators, scrollbars, and empty-state handling. Users will see improved visual consistency, better performance with stable list item keys, and refined UI elements such as the new extension details view and source filter controls.

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

The build logic has been restructured to centralize build flags and improve build metadata handling. A new BuildConfig interface defines build variants (LOCAL, CI, GITHUB, FOSS) that control features like telemetry, updater availability, and Crashlytics mapping uploads based on the distribution profile. Additionally, BuildInfo introduces Git value sources to reliably fetch the latest commit SHA, count, and timestamp, falling back to defaults if Git commands fail, ensuring consistent build identification.

gradle/build-logic/src/main/kotlin/mihon/gradle · high confidence

The application now stores chapter and cover cache files in external cache directories (specifically under the app's external files directory) rather than the internal cache directory. This change introduces new \ChapterCache\ and \CoverCache\ classes that manage these external storage locations, allowing for better storage management and potentially avoiding issues with internal storage limits or cleanup policies.

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

The application now uses a new CategoryRepositoryImpl in the data layer to handle category persistence, replacing previous implementations. This change introduces direct SQLDelight queries for creating, updating, and retrieving categories, and integrates with the Metro dependency injection framework for binding the repository. Users benefit from a more structured data access pattern that separates domain logic from data storage, ensuring consistent category management across the app.

data/src/main/java/tachiyomi/data/category · high confidence

The category management interface has been rewritten using Jetpack Compose, replacing the previous implementation. This update introduces native drag-and-drop functionality for reordering categories, allowing users to easily rearrange their list. The screen now utilizes a modern UI component structure, including a dedicated floating action button for creating new categories and an empty state view when no categories exist. Additionally, a new extension property ensures that system categories are consistently labeled as 'Default' in the UI, regardless of their internal storage name.

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

The category management interface has been rebuilt using the Voyager navigation library and the Metro dependency injection framework. This change introduces a new \CategoryScreen\ and \CategoryViewModel\ that handle creating, renaming, deleting, and reordering categories, replacing the previous implementation. Users will see the same category management capabilities (create, rename, delete, reorder) but powered by the new architecture, which includes improved state management via \StateFlow\ and dialog handling for category operations.

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

The build logic now consolidates Kotlin setup into a dedicated configuration module. This change introduces a new file that handles Java compatibility settings and provides helper functions to configure Kotlin compiler options, streamlining how the project applies these build settings across modules.

gradle/build-logic/src/main/kotlin/mihon/gradle/configurations · medium confidence

The app now consolidates user interface settings into a single UiPreferences class, introducing support for Monet-based dynamic theming on compatible devices, a toggle to render images within manga descriptions, and a simplified relative timestamp display. Date formatting is also standardized using Java.time APIs to ensure consistent localized date handling across the application.

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

The app update checking logic has been moved into the data layer via the new AppUpdateChecker class, which delegates to the GetApplicationRelease interactor. This change introduces support for distinguishing between FOSS and nightly build types, directing update checks to the appropriate GitHub repositories (mihonapp/mihon or mihonapp/mihon-preview) and using the correct release tag formats (version-based for stable, commit-count-based for nightly).

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

The app now consolidates source browsing, extension management, and migration settings into a dedicated \SourcePreferences\ class. This change introduces new user-facing options including the ability to enable or disable specific content warnings for installed extensions, hide library items while browsing sources, configure migration sorting and deep search modes, and manage trusted extensions and external repositories.

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

The new BaseActivity class now automatically applies the user's selected app theme and manages secure-screen behavior for all activities that inherit from it. This ensures consistent theming and security settings across the app without requiring individual activity implementations to handle these concerns.

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

The chapter data module has been rewritten to use SQLDelight for database operations and Metro for dependency injection. The new ChapterRepositoryImpl handles chapter persistence, retrieval, and updates via generated SQL queries, while ChapterSanitizer provides utility functions for cleaning chapter titles. This change replaces the previous data access implementation with a modern, type-safe database layer.

data/src/main/java/tachiyomi/data/chapter · high confidence

The database layer for chapters and tracking history has been rewritten in Kotlin, introducing new model interfaces and implementations. Chapter tracking now uses a Double type for the last chapter read field, allowing for fractional chapter values, and includes a new bookmark state alongside the existing read status. The tracking models now explicitly support private tracking settings and include fields for start and finish dates, providing more granular control over reading history synchronization.

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

The application's data layer has been migrated to use SQLDelight, replacing the previous database implementation with a new set of schema definitions for categories, chapters, history, manga, sources, and tracking. This change introduces new database tables and queries, including support for excluded scanlators, extension stores, and manga synchronization, which may affect how data is stored and retrieved. Users should expect a one-time database migration upon updating, which could impact performance briefly during the first launch.

data/src/main/sqldelight/tachiyomi/data · high confidence

This release applies a series of database migrations to the local storage. It introduces new columns for manga and chapter notes, private tracking flags, and versioning triggers to support syncing. It also adds performance indexes, renames the extension repository table to extension store, and fixes historical data issues such as rescaling Kitsu scores and correcting remote IDs. Additionally, the Updates view is enhanced to include chapter URLs and excluded scanlators.

data/src/main/sqldelight/tachiyomi/migrations · high confidence

The app now uses a dedicated DelayedTrackingUpdateJob to handle background synchronization of reading progress, which retries failed updates up to three times and replaces existing work requests to prevent spam. Track-related settings, including per-tracker credentials, score types (AniList, Kitsu, MangaBaka), and auto-update behaviors, are now managed through a centralized TrackPreferences class.

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

The logic for deleting downloaded chapters has been extracted into a new domain-layer interactor (DeleteDownload). This change centralizes the download deletion workflow, ensuring it is handled consistently via the domain model rather than scattered across UI or data layers.

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

The download queue UI has been restructured to group individual chapter downloads under collapsible headers for each source. This change introduces a new adapter and view hierarchy (using FlexibleAdapter) that displays source names and download counts, allowing users to manage and reorder downloads within specific source groups rather than as a single flat list.

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

The migration config screen now includes a detailed configuration sheet allowing users to select specific data types to migrate (such as reading history, bookmarks, and notes) via filter chips, and provides additional controls like an extra search query field, options to hide unmatched or outdated entries, and advanced settings for deep search mode and prioritization by chapters. The main screen also supports reordering selected sources and offers quick selection actions (select all, none, enabled, pinned).

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

The Extension Details and Source Preferences screens have been rewritten using the Voyager navigation library and Jetpack Compose, replacing the previous Android Fragment-based implementation. This change introduces a new \ExtensionDetailsScreen\ and \SourcePreferencesScreen\ that leverage the Metro dependency injection system for view models, improving navigation consistency and reducing crashes associated with source loading. Users will experience a more stable interface when viewing extension details and configuring source preferences, with better handling of uninstalled sources and incognito mode toggles.

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

The extension management system has been refactored to use Kotlin Coroutines and Kotlin Flows instead of the previous RxJava-based implementation. This change improves thread handling and performance by loading extensions off the main thread and using reactive streams for state updates. The new \ExtensionManager\ class manages the lifecycle of installed extensions, handles updates, and provides a more robust mechanism for trusting and loading extensions. Additionally, a new \InstallStep\ enum has been introduced to track the status of extension installations, providing clearer feedback on the installation process.

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

The extension store model has been updated to replace the legacy binary NSFW flag with a granular ContentWarning enum (Safe, Mixed, NSFW) at the individual extension level. This change aligns with the new extension index format, allowing stores to specify content warnings for each extension rather than marking the entire store as NSFW. Legacy extension repos are still supported via a migration path that maps the old NSFW integer to the new warning system.

data/src/main/java/mihon/data/extension/model · high confidence

The Extensions tab and its filter screen have been rebuilt using Jetpack Compose and the Voyager navigation library, replacing the previous implementation. This change introduces a new filter interface for managing enabled languages, adds a confirmation dialog when removing privately installed extensions, and enables opening extension source websites in a WebView. The underlying ViewModel logic now uses Metro for dependency injection and optimizes data collection to only run while the UI is subscribed, improving performance and responsiveness during browsing.

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

The history module's data layer has been refactored to use the Metro dependency injection framework (replacing previous mechanisms) and updated to use SQLDelight's async coroutine drivers (awaitAsList, awaitAsOne) for database operations. This change introduces a new HistoryMapper for converting database rows to domain models and updates HistoryRepositoryImpl to bind via Metro, ensuring the history tracking functionality remains stable while improving the underlying architecture.

data/src/main/java/tachiyomi/data/history · high confidence

The History tab and its associated view model have been refactored to use the standard AndroidX ViewModel lifecycle instead of the previous Voyager ScreenModel, and dependency injection has been updated to use Metro. This change ensures the history data collection is properly scoped to the view model's lifecycle, improving resource management and stability when navigating away from the screen.

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

The app now uses a compatibility wrapper for the built-in DelegateLastClassLoader, ensuring that extensions load classes and resources correctly on devices running Android 8.0 (API 26) and below. This change backports the delegation behavior introduced in Android 8.1 (API 27) to older systems, preventing potential class-loading issues for extensions that rely on delegating to the parent class loader first.

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

Mass migration now uses the same smart search logic as individual migrations, ensuring consistent results. The new \BaseSmartSearchEngine\ and \SmartSourceSearchEngine\ implement a multi-query strategy (cleaning titles, stripping brackets/chapter refs, and trying various word combinations) with Levenshtein similarity scoring to better match sources during bulk operations.

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

The category management screen now uses new Material 3 Compose components for its user interface. This includes a floating action button for creating new categories, list items that support drag-and-drop reordering along with rename and delete actions, and dedicated dialog components for creating, renaming, and deleting categories. The rename dialog specifically prevents confirmation if the new name is identical to the current one or if it conflicts with an existing category name, providing immediate visual feedback via error states.

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

The tracker management UI in the manga detail view has been replaced with new Compose-based screens. This change introduces a dedicated dialog for managing tracker entries, allowing users to view, edit, and remove tracked status, chapters, scores, and dates for linked services. It also adds functionality to copy tracker URLs via long-press and open tracker pages in a browser, providing a more integrated and modern interface for tracking management.

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

The application now supports marking tracker entries as private, a capability exposed via a new \private\ field in the domain \Track\ model and its database mapping. Additionally, a new \AutoTrackState\ enum has been introduced to manage user preferences for automatic tracking behavior, offering options to always track, ask for confirmation, or never track.

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

The Kitsu tracker implementation has been rewritten to use Kitsu's GraphQL API instead of the previous REST endpoints, enabling support for the user's chosen Kitsu rating scales (Simple, Regular, and Advanced) and private tracking. This change also introduces automatic status updates when the last chapter is read, refreshes profile information including the user's preferred rating system upon login, and improves search reliability with ID-based lookups and URL-encoded queries.

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

The library screen has been rebuilt using Jetpack Compose, replacing the previous implementation. This change introduces a new \LibraryTab\ composable that serves as the main entry point, managing the toolbar, content display, and bottom action menus. The underlying logic has been refactored into \LibraryViewModel\ and \LibrarySettingsViewModel\, which now leverage the Metro dependency injection framework instead of the previous Voyager ScreenModel pattern. Data models have been updated to use \LibraryItem\ and \LibraryManga\ from the domain layer, and the search functionality now utilizes an AST-based query parser for more robust filtering capabilities.

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

The Library screen components have been rewritten in Jetpack Compose, introducing new grid and list item layouts (Compact and Comfortable) that display manga covers with overlaid or below-cover titles. The update adds visual badges for download counts, unread chapters, and language/local status, and includes a 'Continue Reading' button that only appears when unread chapters are present. A global search prompt is now integrated directly into the library list and grid views, and the toolbar has been updated to support selection modes and explicit overflow menu options for refreshing categories and opening random manga.

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

The library search functionality has been reworked to use an Abstract Syntax Tree (AST) based approach, enabling more complex and structured queries. This change introduces support for logical operators (AND, OR, NOT) and specific field comparisons, including date-based filters for 'Date Added' and 'Next Update' using the new kotlinx-datetime library. Users can now perform precise searches on manga metadata such as title, author, genre, source, and read/unread counts, replacing the previous simpler matching logic.

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

The library settings and delete manga dialogs have been rewritten using Jetpack Compose, replacing the previous implementation. The settings dialog now features a tabbed interface for filtering, sorting, and display options, including new sort capabilities like tracker score and random, and uses Material 3 components like chips and sliders. The delete manga dialog now allows users to selectively remove manga from the library and downloaded chapters via checkboxes.

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

The library update process has been refactored to use dedicated background workers (LibraryUpdateJob and MetadataUpdateJob) that run as foreground services. This ensures updates continue reliably even when the app is in the background, and users now receive a persistent notification showing real-time progress, the list of currently updating titles, and options to cancel or view error logs. The system also warns users if a single source is being queried excessively.

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

The main activity has been completely rewritten using Jetpack Compose, replacing the previous View-based architecture. This change introduces edge-to-edge rendering with dynamic system bar styling that adapts to the current app state (such as incognito mode or indexing status). Navigation is now handled by the Voyager library, allowing screens like Home, Browse, and Settings to be composed directly within the activity. The UI also integrates app state banners (e.g., for incognito mode or download-only status) and uses Material Symbols for icons, providing a more modern and consistent visual experience.

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

The manga list and detail views have been rebuilt using Jetpack Compose, replacing the previous View system. This introduces new components including a swipeable chapter list item with configurable actions, a bottom action menu for bulk operations, and a detailed info header with markdown support for descriptions and notes. The manga cover dialog now supports high-quality WebGPU rendering for HDR images and disables memory caching to ensure the latest cover is always displayed.

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

The Manga detail screen has been completely rewritten using Jetpack Compose, replacing the previous implementation. This change introduces a new \MangaViewModel\ and \MangaCoverViewModel\ to manage state and cover image operations, leveraging the Metro dependency injection framework. The UI now uses Voyager for navigation and collects manga state with lifecycle awareness to ensure data is only fetched while the screen is active. Users will experience a modernized interface with improved performance and stability, including better handling of cover images, chapter lists, and dialog interactions.

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

The Manga domain model now includes extension properties for reading mode and orientation, a TriState-based downloaded filter, and utility functions to convert to/from source models and generate ComicInfo metadata (including chapter numbers, dates, and categories).

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

The manga screen has been significantly restructured to support distinct layouts for small and large screens, introducing a new chapter settings dialog for managing filters, sort modes, and display preferences. Users can now add notes to individual manga via a dedicated notes screen, and the duplicate manga detection dialog has been redesigned to display all duplicates with migration options. The chapter list now includes a missing chapter count indicator, and the download action menu has been updated to offer specific chapter counts (next 1, 5, 10, or 25 chapters) alongside bookmarked and unread filters.

app/src/main/java/eu/kanade/presentation/manga · 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 structured models for search results, user sessions, and series metadata, enabling more robust handling of tracking data such as scores, usernames, and series details within the app.

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

The in-app WebView has been rewritten using Jetpack Compose and the new Metro dependency injection framework. This change replaces the previous implementation with a modern UI stack, introducing a dedicated ViewModel for state management and leveraging Metro for dependency injection. Users benefit from a more consistent and performant web browsing experience within the app, with improved handling of source-specific headers and navigation.

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

The app's visual styling has been migrated from XML-based themes to a Compose-based architecture using Material Expressive Theme. This change introduces support for a wider variety of color palettes, including Catppuccin, Tokyo Night, Nord, Monochrome, and Monet (dynamic color), allowing users to customize the app's appearance with more diverse and modern aesthetic options.

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

The Browse and Global Search screens have been rewritten in Jetpack Compose, introducing new components for source and manga display. Users will see updated visual elements including Material Symbols icons, a new 'In Library' bookmark badge on manga items, and a content warning label system for extensions. The browse interface now supports configurable display modes (List, Compact Grid, Comfortable Grid) via the toolbar, and the global search experience includes source filter chips and a progress indicator during searches.

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

The core networking and security logic has been moved into the new :core:common module. This introduces a centralized NetworkHelper that configures the OkHttp client with a 5 MiB cache, standard timeouts, and support for 12 DoH providers (including Cloudflare, Google, AdGuard, and Mullvad). The AndroidCookieJar now syncs cookies with the system WebView, and a new CloudflareInterceptor handles anti-bot challenges using an embedded WebView. Security is managed via PrivacyPreferences (controlling Crashlytics and analytics toggles) and SecurityPreferences (handling biometric lock, incognito mode, and notification hiding). Additional utilities include a JavaScript engine for source evaluation, rate-limiting interceptors, and HTTP request helpers.

core/common · high confidence

The app's dependency injection system has been migrated from Injekt to Metro, introducing new binding containers and graph utilities to manage application-wide services like the database, JSON/XML parsers, and network helpers. Additionally, the Shizuku-based extension installer has been updated to correctly handle existing extensions by applying the REPLACE\_EXISTING flag during installation, ensuring that updates via Shizuku properly overwrite previous versions rather than failing or leaving stale files.

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

This update introduces a suite of migration scripts that clean up and transform legacy user preferences into the current settings structure. Specifically, the old 'NSFW' flag is replaced with a content warning system, the legacy vertical navigator setting is migrated to the new reader preferences, and custom extension repository URLs are converted to the new extension store format. Additionally, the migration process ensures that category preferences are cleaned of deleted categories, a unique installation ID is generated for feature flags, and background tasks for library updates and backup creation are properly initialized.

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

The application update mechanism has been moved into the data layer, introducing a new service that fetches release information directly from GitHub. This change adds support for FOSS (Free and Open Source Software) builds, allowing the app to select the correct download asset based on the build type. Additionally, release notes now automatically convert GitHub username mentions into clickable profile links for better readability.

data/src/main/java/tachiyomi/data/release · high confidence

The migration dialog UI now presents user-friendly, localized names for the specific data types being migrated (such as chapters, categories, custom covers, notes, and downloaded items) instead of raw identifiers. This change improves clarity for users during the migration process by showing readable strings in their preferred language.

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

The source selection screen in the migration flow has been refactored to use a new MigrateSourceViewModel and a Voyager-based tab screen. This change ensures that the list of available sources is fetched and updated only while the screen is actively visible, improving performance and resource usage. Users will see the same migration source list, but it is now powered by a more robust state management approach that integrates with the app's new dependency injection and navigation systems.

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

The More tab and the new update notification screen have been rewritten using Jetpack Compose. The More screen now features a modern UI with Material Symbols icons, a scrollable list of settings (including Download Queue, Categories, Stats, Data and Storage, Settings, Support Us, About, and Help), and toggle switches for Downloaded Only and Incognito modes. The New Update screen now displays the app version, a markdown-rendered changelog, and stage-aware action buttons (Install, Retry, etc.), providing a consistent and visually updated experience for managing app settings and updates.

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

The MyAnimeList integration has been rewritten to use the official MyAnimeList API, introducing support for reading start/finish dates, ID-based search (prefix 'id:'), and list-title search (prefix 'my:'). The tracker now automatically marks entries as completed when the last chapter is read, filters novels from search results, and handles token expiration and refresh more robustly via an OkHttp interceptor. Search queries are truncated to 64 characters to avoid API errors, and unapproved titles are handled with specific error messaging.

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

The Browse tab now features a new implementation that includes a global search screen accessible by tapping the tab twice, and uses a pager-based tabbed screen for Sources, Extensions, and Migration. The Extensions tab's search query is now hoisted to the Browse tab level, allowing the search state to be shared across tabs. The tab also includes an animated icon and handles navigation to the Extensions tab programmatically.

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

The Source Browse screen has been rewritten in Jetpack Compose, introducing a new UI with filter chips for Popular and Latest listings and a dedicated filter dialog for managing source-specific filters. This change also integrates the source's home URL into the screen's assist content for better accessibility and sharing support.

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

The settings screen now uses a new set of Compose UI components located in the \settings.widget\ package to render preference items. This includes \AppThemePreferenceWidget\ for selecting and previewing app themes (including dynamic color support), \AppThemeModePreferenceWidget\ for choosing light/dark/system modes, and \TrackingPreferenceWidget\ which displays tracker status and allows refreshing user profiles. Additionally, standard preference types such as \SwitchPreferenceWidget\, \ListPreferenceWidget\, \MultiSelectListPreferenceWidget\, \EditTextPreferenceWidget\, and \TriStateListDialog\ have been implemented to replace previous UI patterns, providing a consistent Material 3 experience across the settings menu.

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

The build logic now includes two new Gradle tasks: GenerateLocalesConfigTask, which scans locale resource files to generate an Android locales\_config.xml, and ReplaceShortcutsPlaceholderTask, which processes shortcut XML files by replacing application ID placeholders. These tasks automate the generation of locale and shortcut configuration files during the build process.

gradle/build-logic/src/main/kotlin/mihon/gradle/tasks · high confidence

The application introduces three new SQLDelight views (historyView, libraryView, updatesView) in the data module to structure how reading history, library status, and update feeds are queried. The updatesView specifically enables filtering the Updates tab by read status, bookmark status, and category membership, while also supporting scanlator exclusions and limiting results. The libraryView aggregates chapter counts, read counts, and latest upload/fetch times for favorite manga, and the historyView provides a unified view of reading history with latest read chapter tracking.

data/src/main/sqldelight/tachiyomi/view · high confidence

The backup and restore workflows have been moved into their own dedicated screens (CreateBackupScreen and RestoreBackupScreen) within the Data settings. Users can now configure specific backup options (library, settings) and select a destination file on a dedicated creation screen, while the restore process is handled by a separate screen that validates the backup file and allows selection of restore options. A new StorageInfo component displays available disk space for external storages. This change also includes a prominent MIUI warning banner on both screens to alert users about potential issues on that platform.

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

The extension installation and loading mechanisms have been completely rewritten to improve reliability and user experience. A new background service (ExtensionInstallService) and dedicated broadcast receiver (ExtensionInstallReceiver) now handle extension installs, updates, and removals, ensuring the UI remains responsive and installation progress is tracked accurately. The system now supports multiple installation methods, including a private installer for unofficial extensions and a legacy package installer, with specific workarounds for MIUI devices. Additionally, the extension loader has been updated to support TachiyomiX extension library versions 1.4 and 1.6, and introduces content warning metadata support, allowing users to filter or label extensions based on content warnings.

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

The extension installation process has been refactored to use a new base \Installer\ class that manages a serial queue of APK installations, ensuring that installs are processed one by one and preventing race conditions or crashes during mass install/uninstall operations. Two concrete implementations are provided: \PackageInstallerInstaller\ for standard Android installations and \ShizukuInstaller\ for privileged installations via Shizuku. Both implementations now register their broadcast receivers with \RECEIVER\_NOT\_EXPORTED\, enhancing security by restricting who can send broadcast intents to the installer service. The \ShizukuInstaller\ also includes improved handling for service lifecycle and permission requests to prevent crashes when Shizuku is not running or permissions are denied.

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

The app now uses a dedicated \ExtensionUpdateNotifier\ to manage extension update alerts. This component checks for available updates by comparing installed extension versions against the repository and displays a notification listing the affected extensions. The notification respects the user's privacy settings, specifically the option to hide the content (extension names) in the notification shade, and can be dismissed once updates are installed.

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

This change introduces a set of new utility classes in the presentation layer to support the ongoing migration to Compose. Users benefit from more consistent chapter number formatting, clearer and localized error messages for network and source issues, and smoother screen transitions with predictive back support. Additionally, the app now handles package install permissions more gracefully to avoid UI jank, provides better relative time spans for library updates, and includes helpers for resource handling and window size detection.

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

The backup data models have been rewritten to use a new protobuf serialization format. This change introduces new model classes (Backup, BackupManga, BackupChapter, etc.) that define the schema for exporting and importing library data, including manga, chapters, categories, sources, preferences, tracking, and extension stores. The new structure supports backward compatibility with older backup formats while enabling more robust and structured data handling for future features.

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

The backup and restore process now uses a new protobuf-based format instead of the previous JSON structure, handled by a new BackupDecoder that supports gzip-compressed files. A new BackupFileValidator checks for missing sources and unauthenticated trackers before restoration begins. Notification handling has been refactored into a dedicated BackupNotifier, splitting progress and completion alerts into separate channels and adding specific actions like sharing the backup file or viewing error logs.

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

The reader now uses a new loader system to retrieve chapter pages. A central ChapterLoader selects the appropriate PageLoader implementation based on the source type: DownloadPageLoader for downloaded chapters, ArchivePageLoader for local archive files (CBZ/CBR), DirectoryPageLoader for local image folders, EpubPageLoader for EPUBs, and HttpPageLoader for online sources. This change introduces dedicated loaders for each content type, improving how pages are fetched, cached, and managed during reading.

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

The app now uses a new paging-based system for browsing sources, which deduplicates entries and improves browsing speed. This change introduces SourcePagingSource classes for search, popular, and latest updates, along with new repository implementations (SourceRepositoryImpl and StubSourceRepositoryImpl) that handle source data and stub sources via the database.

data/src/main/java/tachiyomi/data/source · high confidence

The app introduces a set of new domain interactors in the source module to handle source list operations more cleanly. GetEnabledSources now provides a reactive list of enabled sources, applying filters for language and disabled status, case-insensitive alphabetical sorting, and pinning logic (including highlighting the last-used source). GetLanguagesWithSources offers a sorted map of languages to their available sources, respecting enabled language preferences. GetSourcesWithFavoriteCount and SetMigrateSorting enable sorting sources by favorite count or alphabetically during migration, with configurable direction. ToggleSource, ToggleSourcePin, ToggleLanguage, and ToggleIncognito provide dedicated commands for enabling/disabling sources, pinning/unpinning, toggling language filters, and managing per-extension incognito mode. GetIncognitoState checks whether a source is in incognito mode based on global settings or specific extension overrides.

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

The app introduces new data models for theme and UI configuration. AppTheme now includes a broader set of visual themes such as Catppuccin, Tokyo Night, Monochrome, and Nord, alongside deprecated legacy options. TabletUiMode defines specific behaviors for background and screen orientation on tablets. ThemeMode standardizes light/dark/system settings and provides a helper function to apply these modes via AppCompatDelegate.

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

The notification logic in the app has been reorganized into three new files: \NotificationHandler.kt\ centralizes the creation of \PendingIntent\s for actions like opening the download manager, viewing images, installing APKs, and opening URLs; \NotificationReceiver.kt\ acts as the central broadcast receiver handling user interactions such as pausing/resuming downloads, sharing images or backup files, marking chapters as read, and canceling library updates or restores; \Notifications.kt\ defines all notification channel IDs, groups, and their creation logic, including deprecating old channels and setting up groups for library, downloader, backup/restore, and APK updates with specific importance levels and badge settings.

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

The app now includes a custom text input widget that automatically disables personalized learning flags in the on-screen keyboard when Incognito mode is active, enhancing privacy during text entry. Additionally, a new abstract view pager adapter has been introduced to streamline the creation and management of view-based pager items, providing a cleaner base for UI components that rely on page swiping.

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

The reader interface components have been rewritten in Jetpack Compose, introducing a new page actions dialog that includes a 'Copy to Clipboard' option alongside existing share, save, and set-as-cover actions. The migration also adds a configurable e-ink page flash feature (DisplayRefreshHost) to improve visibility on e-ink displays, and updates the chapter transition info, reading mode, and orientation selection dialogs to use the new Compose-based UI with Material 3 styling.

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

The reader interface has been rebuilt using Kotlin and Jetpack Compose, replacing the previous Java-based implementation. This change introduces a new ReaderActivity and ReaderViewModel that manage reading state and configuration, along with a new ReaderNavigationOverlayView that displays tap zones and navigation hints. The UI now uses Compose for overlays, dialogs, and the bottom menu, providing a more consistent and modern reading experience with improved handling of system UI insets and edge-to-edge display.

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

The reader's top and bottom app bars have been rewritten in Jetpack Compose, introducing slide and fade animations for their appearance and disappearance. This change adds support for a vertical chapter navigator, allowing users to browse chapters via a side slider in addition to the existing horizontal bar, and integrates the new Material Symbols icon set for UI elements like bookmarks and settings.

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

The reader configuration UI and logic have been restructured: \ReaderPreferences\ now centralizes all reader settings (such as flash, double-tap zoom, and navigator options) as typed preference properties, \ReaderSettingsViewModel\ exposes these preferences and current state via StateFlows for the Compose UI, and \ReaderOrientation\ and \ReadingMode\ enums have been updated to use new icon resources and map directly to the high-quality WebGPU renderer when enabled.

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

The reader settings dialog has been rebuilt using Jetpack Compose, replacing the legacy Android preference system. This migration introduces a tabbed interface (Reading Mode, General, Color Filter) and modernizes the UI by replacing dropdowns and standard checkboxes with Material 3 Filter Chips and SliderItems. New capabilities include configurable e-ink page flashes (duration, interval, and color), a vertical chapter navigator with adjustable height, and specific WebGPU reader options like dual-page view and continuous scroll gap settings. The dialog also now constrains its height to 75% of the screen and handles display cutouts for Android 15+.

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

The Updates tab has been rebuilt using Jetpack Compose, introducing a new filter dialog that allows users to filter updates by status (downloaded, unread, started, bookmarked) and by specific library categories. The interface now features a Material 3 design with pull-to-refresh, predictive back support, and visual cues such as a dot indicator for unread chapters and a 'last updated' timestamp header. Additionally, a new confirmation dialog handles chapter deletions, and the screen supports multi-select actions for bookmarking, marking as read, and deleting.

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

The Extension Stores settings screen has been rebuilt to use a new Material 3-based UI and a dedicated ViewModel. Users now see a refreshed list of extension stores with improved visual styling, including Material Symbols icons for actions like copying URLs, opening websites, and deleting stores. The screen now supports creating new stores via a dialog that validates for duplicates, deleting existing stores with a confirmation prompt, and refreshing store information. A new ViewModel handles the state and business logic, ensuring that store data is only fetched while the screen is actively subscribed, which improves performance and responsiveness.

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

The home screen now uses a unified NavigationSuiteScaffold that automatically switches between a navigation rail on tablets and a bottom bar on phones. Tab switching is animated with a fade-through effect, and the back button intelligently returns to the Library tab instead of exiting the app when on other tabs. The screen also handles deep links to specific tabs and content, such as opening a manga from the library or the download queue from the More tab.

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

The chapter domain module now includes explicit conversion functions for the Chapter model, ensuring that the \date\_upload\ field is correctly mapped when converting to database records and that the \scanlator\ value is trimmed and normalized when copying from source models. Additionally, the logic for applying view filters (unread, downloaded, bookmarked) and sorting to chapter lists has been consolidated into dedicated utility functions within this module, replacing previous inline implementations.

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

The extension management logic has been restructured into dedicated domain interactors (GetExtensionLanguages, GetExtensionSources, GetExtensionsByType, TrustExtension) that leverage Kotlin Flows for reactive state updates. This change introduces a new trust mechanism where extensions are verified by their repository signing keys in addition to manual user trust, and updates the extension list categorization to include a distinct 'notLoaded' state for extensions that failed to load, ensuring users are aware of them.

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

Telemetry logic has been moved into a dedicated \telemetry\ module, separating Firebase integration from the core app. This change introduces stricter checks to ensure telemetry is only active in official Mihon production builds, verified by package name and certificate fingerprint, preventing fork or debug builds from polluting analytics data. Additionally, the app now explicitly removes unnecessary permissions (such as AD\_ID and install referrer access) via manifest merging and disables automatic Firebase features like ad personalization and screen reporting by default, giving users a more privacy-focused experience while still allowing manual opt-in for analytics and crash reporting.

telemetry · high confidence

The app's base activity logic has been reorganized into two new delegate classes: SecureActivityDelegate and ThemingDelegate. SecureActivityDelegate now centralizes the app lock mechanism, handling screen security, incognito mode restrictions, and the unlock flow (including cold-start behavior and delay settings) via lifecycle observers. ThemingDelegate manages the application of visual themes, mapping specific theme identifiers (such as Catppuccin, Tokyo Night, Lavender, Monochrome, Nord, and Tidal Wave) to their corresponding Android style resources, and supporting amoled variants.

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

The backup restore process has been restructured into dedicated restorer classes (Categories, ExtensionStore, Manga, and Preference) to improve maintainability and data integrity. The CategoriesRestorer now ensures correct ordering when restoring categories and updates display settings accordingly. The MangaRestorer implements a more robust update strategy that preserves existing data while merging new information, handles chapter restoration with better conflict resolution, and includes logic to sort mangas by recency to optimize the restore order. The PreferenceRestorer now correctly maps category IDs to names during restoration, fixing issues where category-based preferences might be lost or misaligned. Additionally, the ExtensionStoreRestorer was added to handle the restoration of extension store configurations, supporting the newer extension index format.

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

The chapter handling logic has been reorganized into dedicated domain interactors: \SetReadStatus\ now manages marking chapters as read or unread, including the conditional removal of downloads when the corresponding preference is enabled; \SyncChaptersWithSource\ handles the synchronization of chapter metadata from sources, including sanitizing chapter names, updating upload dates, and renaming local download folders when necessary; and \GetAvailableScanlators\ provides a clean interface for retrieving the set of scanlators associated with a manga. These changes centralize the business logic for read status updates, source synchronization, and scanlator retrieval within the domain layer.

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

The chapter filtering and navigation logic has been reorganized into three new utility files: ChapterFilterDownloaded.kt, ChapterGetNextUnread.kt, and ChapterRemoveDuplicates.kt. ChapterFilterDownloaded.kt now handles filtering out non-downloaded chapters, respecting local manga sources. ChapterGetNextUnread.kt provides functions to find the next unread chapter, applying filters and sorting direction. ChapterRemoveDuplicates.kt contains logic to remove duplicate chapters from a list, prioritizing the current chapter or matching scanlator. This refactoring improves code modularity and maintainability for chapter-related operations.

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

The extension installer preference logic has been restructured to automatically handle MIUI compatibility. A new \ExtensionInstallerPreference\ class now manages the selection of extension installers (Legacy, PackageInstaller, Shizuku, Private). On MIUI devices, the standard \PACKAGEINSTALLER\ option is hidden from the user, and \LEGACY\ is set as the default. Additionally, the system validates the current selection at runtime, forcing a fallback to the default installer if the chosen option (like Shizuku) is unavailable or if a non-legacy installer is selected on MIUI, ensuring extensions can be installed without requiring manual user intervention for device-specific quirks.

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

The migration process for manga has been restructured to use a new \MigrationFlag\ enum, which manages migration options (such as chapters, categories, notes, custom covers, and downloads) via integer bitmasks instead of previous preference getter functions. The \MigrateMangaUseCase\ now explicitly checks these flags to conditionally migrate chapter read states, bookmarks, categories, tracker data, and custom covers, ensuring that only selected data types are transferred during the migration from a source to a target manga entry.

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

The tracking domain logic has been reorganized into specific interactor classes (AddTracks, RefreshTracks, SyncChapterProgressWithTrack, TrackChapter) to improve code structure and maintainability. This change introduces a new \SyncChapterProgressWithTrack\ interactor that handles the synchronization of local chapter read status with remote tracker data, ensuring that local progress is correctly reflected on the tracker side. The \AddTracks\ interactor now manages the binding of manga to trackers, including the logic for retaining remote last chapter read values if they are higher than local ones. The \RefreshTracks\ interactor centralizes the fetching of updated tracking data from all logged-in trackers. The \TrackChapter\ interactor handles the updating of chapter progress on remote trackers, including the setup of delayed tracking update jobs on failure to prevent spam. These changes are part of a broader effort to clean up and refactor tracking-related logic.

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

The application-level Dagger 1 infrastructure, including the \App\ class, \AppComponent\ interface, and \AppModule\, has been removed from the codebase. This change eliminates the manual setup of the application component and the provision of the \Application\ singleton via Dagger 1, indicating a migration away from this dependency injection version.

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

The build system in the \gradle/build-logic\ module has been rewritten to use a new set of Kotlin plugins and extension functions. This introduces dedicated plugins for Android application, library, test, and multiplatform targets, as well as Compose and Spotless configuration. The new logic centralizes SDK version management (compile, min, target, NDK) and enables core library desugaring by default. It also standardizes dependency declarations via new \api\, \debugApi\, and \coreLibraryDesugaring\ extension functions, and configures Spotless with ktlint for Kotlin, Kotlin Gradle, and XML files. This change affects how the project's build configuration is structured and applied.

gradle/build-logic/src/main/kotlin · high confidence

The download system has been completely rewritten to replace the previous RxJava-based service with a modern architecture using Kotlin Coroutines and Android's WorkManager. The download process is now managed by a \DownloadJob\ worker that handles network checks and foreground notifications, while a new \DownloadManager\ coordinates the queue and interacts with a rewritten \Downloader\ that uses \SharedFlow\ for state management. A new \DownloadCache\ class indexes the filesystem to improve UI performance, and \DownloadStore\ persists active downloads using kotlinx.serialization. This change improves reliability, reduces memory usage, and ensures downloads survive process death.

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

The history screen has been rewritten using Jetpack Compose, replacing the previous implementation. This update introduces a new UI structure featuring a search toolbar, fast-scrolling list with relative date headers, and specific actions for resuming, favoriting, and deleting history items. It also includes dedicated empty and loading states to improve the user experience when no data is available or while content is loading.

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

The settings screen has been rebuilt using Jetpack Compose, replacing the previous implementation with a new modular architecture defined in the \Preference\ sealed class hierarchy. This change introduces distinct preference types—including Switch, Slider, List, MultiSelect, EditText, Text, Info, Custom, and Tracker preferences—each with dedicated Compose widgets and a unified \PreferenceScreen\ that supports grouping and search highlighting. The new system also adds specific UI behaviors for trackers, such as observing login states and displaying refresh result toasts, while standardizing the layout via \PreferenceScaffold\ and \PreferenceGroupHeader\ components.

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

The migration engine has been completely rewritten to use a new, coroutine-based architecture. This introduces a structured \Migration\ interface and a \MigrationContext\ for handling version checks and dry-runs, replacing the previous implementation. Execution is now managed by a \MigrationJobFactory\ and various \MigrationStrategy\ classes (such as \DefaultMigrationStrategy\ and \VersionRangeMigrationStrategy\) that run migrations sequentially on an IO thread pool. This change aims to improve reliability and prevent UI freezes or thread starvation during the migration process.

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

The settings interface has been reorganized from a single monolithic screen into distinct, dedicated Compose screens for each category (Appearance, Browse, Data, Downloads, Library, and Advanced). This change introduces a new \SearchableSettings\ interface and a \Commons.kt\ utility for category labels, enabling a unified, searchable settings experience with consistent Material 3 styling and Voyager navigation.

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

The Settings screen has been rewritten to use the Voyager navigation library, replacing the previous implementation. On mobile devices, it now uses a nested navigator to handle sub-screens (About, Data and Storage, Tracking, and Main) with standard screen transitions. On tablet devices, the layout switches to a two-pane view: the left pane displays the main settings list, while the right pane shows the selected sub-screen content, with system bar insets properly handled. The 'Backup and restore' section has been renamed to 'Data and storage' in the navigation destinations.

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

The Shikimori tracker integration has been completely rewritten to use Shikimori's GraphQL API instead of the previous REST endpoints, and switched from Gson to kotlinx.serialization for JSON parsing. This change introduces new DTOs for OAuth, search results, and user lists, and updates the API client to use OkHttp's awaitSuccess() pattern. For users, this means the tracker now supports ID-based searches (prefix 'id:') and provides more robust handling of authentication token refreshes via the new interceptor.

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

The source API has been extracted from the app module into a dedicated \source-api\ library, providing the core interfaces (\Source\, \CatalogueSource\, \HttpSource\) and data models (\SManga\, \SChapter\, \Page\) used by extensions. This change modernizes the API by introducing suspend functions for data fetching (replacing deprecated RxJava \Observable\ methods), adds support for source-specific preferences via \ConfigurableSource\, and introduces new capabilities like URI resolution (\ResolvableSource\) and unmetered source identification. The module also includes R8 rules to ensure these public APIs are preserved during obfuscation.

source-api · high confidence

The source manager now waits for extensions to fully load before exposing the list of available sources, preventing race conditions where the UI might receive an empty or incomplete list. This change introduces an asynchronous loading mechanism using Kotlin Flows, ensuring that the source list is only propagated once all extensions and local sources are initialized. Additionally, source names in manga info are now intelligently formatted to hide language tags when only one language is enabled, improving readability for users with filtered source lists.

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

The Sources browsing and filtering interfaces have been rewritten in Jetpack Compose, replacing the previous implementation. This change introduces a new SourcesViewModel and SourcesFilterViewModel that manage state using Coroutines flows and are injected via the Metro dependency injection framework. Navigation between the main sources list, the source filter screen, and global search is now handled by the Voyager library, allowing users to filter sources by language and toggle their enabled status through a modern, composable UI.

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

The extension repository now supports multiple extension stores, allowing each store to have its own separate extension list file. This change introduces a new \ExtensionStoreRepositoryImpl\ that manages store configurations (including index URLs, names, and signing keys) and fetches extensions from all configured stores concurrently. Users can now add and manage multiple extension sources, with the system handling updates and removals for each store independently.

data/src/main/java/mihon/data/extension/repository · high confidence

The data layer for the tracking feature has been refactored to use the Metro dependency injection framework, replacing the previous mechanism with explicit \@Inject\ and \@ContributesBinding\ annotations on \TrackRepositoryImpl\. Additionally, database queries now utilize SQLDelight's async coroutine drivers (\awaitAsList\, \awaitAsOneOrNull\) instead of synchronous execution, and a new \TrackMapper\ object handles the conversion from database rows to the domain \Track\ model, ensuring the \private\ tracking status is correctly persisted and retrieved.

data/src/main/java/tachiyomi/data/track · high confidence

The tracking subsystem has been restructured to improve code organization and extensibility. A new abstract BaseTracker class now provides shared implementation for common tracker behaviors such as credential management, login state observation via flows, and remote update handling. New interfaces (Tracker, DeletableTracker, EnhancedTracker) define clearer contracts for tracker capabilities. The TrackerManager has been updated to instantiate and manage all supported trackers (MyAnimeList, AniList, Kitsu, Shikimori, Bangumi, Komga, MangaUpdates, Kavita, Suwayomi, Hikka, MangaBaka) using the new structure, ensuring consistent behavior across all integrated services.

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

The extension store service now handles both the newer extension index format and legacy store formats within a single unified component. It automatically detects and decompresses gzip-compressed responses for both index and extension list files, improving performance and compatibility. The service also includes logic to automatically migrate from legacy extension store indices, ensuring a seamless transition for existing users while supporting separate extension list files for modern stores.

data/src/main/java/mihon/data/extension/service · high confidence

The app now uses a centralized ImageSaver component to handle saving both manga pages and covers. For devices running Android 10 (API 29) or higher, images are saved directly to the MediaStore using the appropriate Pictures or Documents directory based on MIME type, ensuring they appear correctly in the system gallery. The saved images are assigned a 'Date Modified' timestamp based on the current time in seconds. For older Android versions, or when saving to the cache, the previous file-system-based approach is retained. This change also ensures that media scanner intents are triggered after saving to update the system's media library.

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

The tracker authentication flow has been consolidated into a single entry point, TrackLoginActivity, which now handles OAuth callbacks for AniList, Bangumi, MyAnimeList, Shikimori, the newly added MangaBaka, and the newly added Hikka. This change replaces the previous scattered activity structure with a centralized router that parses the incoming OAuth URI (supporting both query parameters and fragments) and dispatches the credentials to the appropriate tracker manager, while also introducing a base activity that uses a Compose-based loading screen during the process.

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

The app module now includes a new \google-services.json\ file to configure Firebase services for the \app.mihon\ package, and the \proguard-rules.pro\ file has been significantly expanded. These new rules ensure that core application classes (\eu.kanade\, \tachiyomi\, \mihon\) and critical dependencies (RxJava, OkHttp, kotlinx.serialization, Kotlinx Datetime, Firebase) are preserved during optimization, preventing runtime crashes in release builds. Additionally, a standard \proguard-android-optimize.txt\ file was added, and the previous \app/.gitignore\ file was removed.

app · high confidence

The Updates screen can now filter updates by specific categories, allowing users to narrow down the list of recent chapters based on their assigned categories. This change introduces new parameters for included and excluded categories in the repository layer, enabling more granular control over which updates are displayed.

data/src/main/java/tachiyomi/data/updates · high confidence

The app's image loading infrastructure has been upgraded from Coil 2.x to Coil 3. This change introduces a new custom decoder that utilizes libvips (via the \ImageDecoder\ library) to support advanced image formats such as AVIF, JXL, HEIF, and JP2, which were not previously supported by the Android system decoder. The \MangaCoverFetcher\ has been rewritten to align with Coil 3's API, including updated caching logic and the use of Okio for file system operations. Additionally, new utility functions and request options (such as \cropBorders\, \customDecoder\, and \newDecoder\) have been added to control image processing behavior.

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

The WebView screen now uses the Voyager library for navigation state management and the KevinZou WebView Compose library instead of the previous implementation. This change introduces multi-window support, allowing new tabs to be opened via user gestures, and adds a help banner that appears when a Cloudflare captcha page is detected. It also improves URL handling by ignoring 'intent://' links and directly tracking the current URL to prevent duplicate requests.

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

Added DummyTracker test fixture; Added tests for manga fetch interval calculation logic; Added unit tests for LibraryFlags; Added unit tests for application release checking logic; Added unit tests for chapter recognition and missing chapter logic; Added unit tests for the migration strategy system; Removed legacy unit tests and test configuration.

The application module now includes a comprehensive build configuration defining the app namespace, versioning (v0.20.4), and multiple build variants including standard release, FOSS, nightly, and benchmark builds. This setup integrates essential plugins for Compose, Spotless, AboutLibraries, and optional Firebase Crashlytics, while configuring ABI splits for multiple CPU architectures and enabling ProGuard/R8 resource shrinking for optimized release builds.

(dependencies) · high confidence

The project's Gradle wrapper has been updated from version 2.2.1 to 9.7.1. This change also introduces new configuration properties for the wrapper, including network timeout, retry logic, and distribution URL validation, which enhance the reliability and security of the build environment setup.

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 47 → 50 (+3.2)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 80 → 86 (+6.6)
• Architecture 99 → 87 (-11.3)
• Maturity 55 → 55 (+0.0)
• Readiness 34 → 40 (+5.5)
• Security 44 → 46 (+2.4)
• Domain Modelling 100 → 100 (+0.0)

• BrowseSourceScreenModel.searchGenre (cognitive 23) (app/src/main/java/eu/kanade/tachiyomi/ui/browse/source/browse/BrowseSourceScreenModel.kt)
• Change coupling: ArchivePageLoader.kt ↔ UniFileExtensions.kt (app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader/ArchivePageLoader.kt)
• Change coupling: DownloadPageLoader.kt ↔ UniFileExtensions.kt (app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader/DownloadPageLoader.kt)
• Change coupling: EpubPageLoader.kt ↔ UniFileExtensions.kt (app/src/main/java/eu/kanade/tachiyomi/ui/reader/loader/EpubPageLoader.kt)
• Change coupling: EpubReader.kt ↔ UniFileExtensions.kt (core/archive/src/main/kotlin/mihon/core/archive/EpubReader.kt)
• Change coupling: GlobalSearchScreen.kt ↔ GlobalSearchScreenModel.kt (app/src/main/java/eu/kanade/presentation/browse/GlobalSearchScreen.kt)
• Change coupling: MigrateSearchScreen.kt ↔ GlobalSearchScreen.kt (app/src/main/java/eu/kanade/tachiyomi/ui/browse/migration/search/MigrateSearchScreen.kt)
• Change coupling: UniFileExtensions.kt ↔ LocalSource.kt (core/common/src/main/kotlin/tachiyomi/core/common/storage/UniFileExtensions.kt)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (app/src/main/java/eu/kanade/presentation/browse/components/BrowseSourceComfortableGrid.kt)
• Duplicated block (10 lines × 2) (app/src/main/java/eu/kanade/presentation/components/TabbedDialog.kt)
• Duplicated block (10 lines × 2) (app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsReaderScreen.kt)
• Duplicated block (10 lines × 2) (app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsReaderScreen.kt)
• Duplicated block (10 lines × 2) (app/src/main/java/eu/kanade/tachiyomi/ui/reader/viewer/pager/PagerPageHolder.kt)
• Duplicated block (10 lines × 3) (app/src/main/java/eu/kanade/tachiyomi/data/track/kavita/Kavita.kt)
• Duplicated block (10 lines × 5) (core/common/src/main/kotlin/eu/kanade/tachiyomi/network/DohProviders.kt)
• Duplicated block (11 lines × 2) (app/src/main/java/eu/kanade/presentation/browse/components/BrowseSourceComfortableGrid.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/tachiyomi/data/notification/NotificationReceiver.kt)
• …and 64 more

• Boundary-crossing change coupling: LibrarySettingsDialog.kt ↔ SettingsItems.kt (app/src/main/java/eu/kanade/presentation/library/LibrarySettingsDialog.kt)
• BrowseSourceViewModel.searchGenre (cognitive 23) (app/src/main/java/eu/kanade/tachiyomi/ui/browse/source/browse/BrowseSourceViewModel.kt)
• Change coupling: GlobalSearchScreen.kt ↔ MigrateSearchViewModel.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: HomeScreen.kt ↔ SettingsScreen.kt (app/src/main/java/eu/kanade/tachiyomi/ui/home/HomeScreen.kt)
• Change coupling: MangaMapper.kt ↔ MangaRepositoryImpl.kt (data/src/main/java/tachiyomi/data/manga/MangaMapper.kt)
• Change coupling: MigrateSearchScreen.kt ↔ MigrateSearchViewModel.kt (app/src/main/java/eu/kanade/presentation/browse/MigrateSearchScreen.kt)
• Change coupling: SourcePreferences.kt ↔ SettingsBrowseScreen.kt (app/src/main/java/eu/kanade/domain/source/service/SourcePreferences.kt)
• Change coupling: TrackInfoDialogSelector.kt ↔ TrackInfoDialog.kt (app/src/main/java/eu/kanade/presentation/track/TrackInfoDialogSelector.kt)
• ClassTooLong: LibraryViewModel (app/src/main/java/eu/kanade/tachiyomi/ui/library/LibraryViewModel.kt)
• ClassTooLong: MangaViewModel (app/src/main/java/eu/kanade/tachiyomi/ui/manga/MangaViewModel.kt)
• ClassTooLong: ReaderActivity (app/src/main/java/eu/kanade/tachiyomi/ui/reader/ReaderActivity.kt)
• ClassTooLong: ReaderViewModel (app/src/main/java/eu/kanade/tachiyomi/ui/reader/ReaderViewModel.kt)
• ClassTooLong: WebGpuViewer (app/src/main/java/eu/kanade/tachiyomi/ui/reader/viewer/webgpu/WebGpuViewer.kt)
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsLibraryScreen.kt)
• Duplicated block (10 lines × 2) (app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsReaderScreen.kt)
• Duplicated block (10 lines × 2) (app/src/main/java/eu/kanade/tachiyomi/data/track/bangumi/BangumiApi.kt)
• …and 170 more

• 150 commits — 134 feature/other, 16 fixes

• app/src — 67 commits
• gradle/libs.versions.toml — 49 commits
• (root) — 8 commits
• i18n/src — 7 commits
• .github/workflows — 4 commits
• gradle/build-logic — 4 commits
• gradle/wrapper — 2 commits
• .github/ISSUE_TEMPLATE — 1 commit
• app/build.gradle.kts — 1 commit
• app/proguard-rules.pro — 1 commit
• core/common — 1 commit
• data/src — 1 commit
• gradle/mihon.versions.toml — 1 commit
• icons/material-symbols — 1 commit
• presentation-core/src — 1 commit
• source-local/src — 1 commit

• fix: Bump webgpuviewer, fix animated images background color (#3843)
• fix: Bump webgpuviewer, fix navigation directions and long strip bounds (#3870)
• fix: Bump webgpuviewer, imagedecoder, fixes (#3852)
• fix: Fix GPU texture leak when a decoded page is no longer usable (#3872)
• fix: Fix Mangabaka dates drifting in negative timezones (#3711)
• fix: Fix default category and manga sometimes not having their category restored (#3891)
• fix: Fix fit height to in new renderer and bump webgpuviewer (#3801)
• fix: Fix inverted MAL OAuth expiry check logic (#3927)
• fix: Fix library search when clicking source name in manga info screen (#4002)
• fix: Fix padded year & 31-clamped month in local source (#3970)
• fix: Fix page loading for webgpuviewer and bump version (#3823)
• fix: Fix unhelpful generic 401 error on AniList expiry (#3888)
• fix: Fix wrong MangaBaka scores for step sizes > 1 (#3740)
• fix: Fixed crash caused by incorrect handling of kitsu score type from login (#3887)
• fix: [skip ci] Fix PR reference in Changelog (#3741)
• fix: webgpuviewer: Fix menu hiding when navigating in long strip (#3956)
• change: Add id: prefix search for rest of third-party trackers (#3776)
• change: Add high quality WebGPU renderer (#3388)
• change: Add refresh button to tracker for new profile info (#3828)
• change: Add score info to MangaUpdates search results (#3795)
• …and 130 more

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

mihonapp/mihon 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.