fragmject: A Kotlin and Compose learning project that trades third-party libraries for readable code

What fragmject is for and who should care

fragmject exists because the author found Kotlin learning materials too abstract and real open-source projects too layered with business logic and wrappers. The README states the goal directly: a complete app that follows official Android Developer practices, with no complex business and no extra encapsulation. The intended user is a developer who already knows basic Kotlin and Android concepts but has not built a full app with Compose and modern architecture. The project covers MVVM and MVI, Navigation 3, WindowSizeClass, Room, Hilt, and even bytecode instrumentation with ASM. If you are that beginner, fragmject gives you a single codebase to read top to bottom. If you are an experienced engineer looking for a reusable template, the project's deliberate simplicity will feel like a limitation, not a benefit.

Architecture: MVVM/MVI hybrid with a thin core

The repository is split into core, feature, and app modules. The app module is a shell with one Activity, WanActivity.kt, an Application class for Hilt, and a navigation graph. The core module contains a designsystem package, and feature modules hold the actual screens. The README describes the architecture as MVVM/MVI mixed. In practice that means ViewModels hold UI state and events flow through SharedFlowBus, a 30-line message bus implemented with Kotlin's SharedFlow. The bus supports sticky messages, which is a simple way to share events between screens without adding a full event bus library. The navigation layer uses Navigation 3, which the README calls type-safe navigation with NavBackStack and NavDisplay. That is a recent and less documented API than Navigation 2, so expect to read the official docs alongside the code.

WindowSizeClass adaptive layouts: the most concrete feature

The project implements responsive layouts using material3-window-size-class. The strategy is explicit in a table: compact widths under 600dp use a bottom NavigationBar and push details full screen; medium widths from 600 to 840dp use a left NavigationDrawerItem with a Surface; expanded widths at or above 840dp use a PermanentNavigationDrawer and render list-detail on the same screen. The code example shows a when statement on WindowWidthSizeClass that dispatches to three different composables. The list-detail pattern is the standout: on a tablet or desktop window, tapping an article or user link renders the destination in a right-side DetailPane instead of navigating away. The relevant files are LocalWindowSizeClass.kt for the CompositionLocal injection, WanNavGraph.kt for intercepting NavKey in expanded mode, and MainScreen.kt for the three-state layout dispatch. This is the part of the project that most clearly teaches a production-relevant skill.

Getting it running: environment and build setup

The README insists you update Android Studio first, and notes you may need a proxy or VPN to do so. It points to the version catalog at gradle/libs.versions.toml for AGP and Compose versions. The build uses Gradle Kotlin DSL, Version Catalog, and Convention Plugins, so the build files are split into small pieces. To run the app, you open the project in a current Android Studio, let it sync the Gradle files, and run the app module. There is an APK link in the README, but it points to a release named wan-release-1.6.0-free.apk, which is older than the latest tag v1.1.0 from 2021-08-15. That mismatch suggests the README is not fully maintained. The project also has a dictionary folder and proguard-rules.pro for release builds, so you can build a signed APK if you configure the signing keys yourself.

Why it avoids third-party libraries and what that costs

The README gives two reasons for avoiding libraries: they add learning burden because their internals are complex, and they let beginners mistake library knowledge for real skill. So fragmject implements its own image picker, editor, calendar, wheel picker, immersive mode, screen recording, and even bytecode instrumentation plugins. That is a deliberate trade-off. You will learn how these components work, but you will also maintain them yourself. The author admits the implementations may not be elegant. For a learner that is fine. For anyone who needs a production app, hand-rolling a screen recorder or an image editor is a liability. The project does still use Hilt, Room, Retrofit, and OkHttp, so it is not a no-dependency purist. It just avoids libraries where the author thinks reimplementation teaches more.

Real limitations and failure modes

The most obvious limitation is version risk. The README lists Kotlin 2.4.x and Navigation 3, which are not stable mainstream versions as of the last push in 2021. The project has not been updated since August 2021, so those versions are now several years old. If you open the project today, you will likely face Gradle sync errors and deprecation warnings. The README even says you can configure AGP and Compose yourself, which implies the pinned versions may not work out of the box. Another limitation is the single-Activity architecture: everything lives in WanActivity.kt and WanNavGraph.kt, which keeps things simple but also means you do not learn about multi-module navigation in a real sense. The SharedFlowBus is a custom event bus, and the README does not discuss thread safety or lifecycle edge cases. For a beginner that is acceptable, but for a team evaluating it as a foundation, these are red flags.

Alternative: official Compose samples and Now in Android

If fragmject's approach feels too idiosyncratic, the obvious alternative is the Android team's own Now in Android sample app. That project uses the same stack: Kotlin, Compose, MVVM, Hilt, Room, and Navigation, but it is actively maintained by Google and follows the latest stable APIs. The difference in approach is that Now in Android uses the canonical library versions and does not reimplement basic components. It is larger and more abstract, which is exactly what fragmject's author wants to avoid. Another alternative is the official Compose samples repository, which gives you small, focused examples rather than a full app. If you want to learn a specific topic like WindowSizeClass or Navigation, those samples are more direct. fragmject's value is the opposite: it is a single coherent app you can read end to end, with the author's own articles linked for each feature.

Maintenance, license, and what to verify first

The project is licensed under Apache-2.0, so you can use and modify it freely, with attribution. There are no recent releases beyond v1.1.0 from August 2021, and the default branch is master with no archived flag, so it is not officially abandoned but it is dormant. Maintenance cost is high if you adopt it: you must update the version catalog, migrate to newer Kotlin and Compose versions, and re-test the custom components. The README links to many Chinese-language articles on Juejin, which are useful if you read Chinese, but they are not translated in the repo. Before you invest time, check the libs.versions.toml file to see if the declared versions match your Android Studio. Also check the tag v1.3.0 if you want the non-Compose version. The project works as a learning artifact, but treat it as a snapshot from 2021, not a living codebase.

Editorial conclusion

Adopt fragmject if you are a Kotlin or Compose beginner who wants a complete, working app that follows official Android guidance and explains its own code. Do not use it as a production baseline: the project pins bleeding-edge versions like Kotlin 2.4.x and Navigation 3, and it intentionally reimplements features that mature libraries handle more safely. Before you start, verify that your Android Studio and Gradle versions match the version catalog in libs.versions.toml, and check the tag v1.3.0 if you need a non-Compose variant. The real value is in the source and the linked articles, not in running the app.

Official sources

1. Official README
2. Project repository
3. Release notes