Android engineer building thoughtful software — and tinkering with hardware, games, and ideas on the side.

6 minute read

Have you ever needed to read a markdown file on your phone and found yourself stuck between bad options? You could install a bloated note-taking app with features you don’t need, use a clunky web browser to view files from cloud storage, or worse—try squinting at raw markdown syntax. None of these feel quite right.

That’s the problem LightMarkdownReader was built to solve: a purpose-built, lightweight markdown reader for Android that does one thing exceptionally well.

Why You Need a Lightweight Markdown Reader on Your Phone

If you work with markdown files regularly, you’ve probably experienced these scenarios:

For Developers: You’re away from your computer and need to quickly check a project’s README or review technical documentation. Maybe you’re in a meeting and want to reference API docs, or you’re reviewing a pull request description on the go.

For Writers: You’ve drafted a blog post in markdown and want to preview how it looks before publishing. Or you need to review your notes from anywhere without firing up a full-featured editor.

For Students: Your lecture notes are in markdown format, and you want to review them on your commute without internet access or unnecessary distractions.

The common thread? You just want to read markdown files—quickly, cleanly, and without fuss. You don’t need cloud sync, collaboration features, or a subscription. You certainly don’t need an app that takes 100MB+ of storage and runs background processes.

What you need is a tool that respects three things:

  1. Your time - Fast startup, instant rendering
  2. Your privacy - Local files only, no cloud requirement
  3. Your device - Minimal storage, battery, and memory usage

What Makes “Lightweight” Actually Lightweight

When apps claim to be “lightweight,” they often just mean “we have a minimalist UI.” But truly lightweight goes deeper—it’s about architectural decisions and technical trade-offs that prioritize efficiency.

LightMarkdownReader achieves genuine lightweight status through several key choices:

Smart Rendering Strategy

Most markdown apps on mobile take the easy route: they render markdown to HTML and display it in a WebView (essentially an embedded web browser). While this works, it’s heavyweight—WebView adds significant memory overhead, slower rendering, and a non-native feel.

LightMarkdownReader uses Markwon, a library that renders markdown directly to Android’s native TextView using Spannables. Here’s the entire rendering implementation:

@Composable
fun MarkdownContent(
    markdown: String,
    modifier: Modifier = Modifier
) {
    val context = LocalContext.current
    val textColor = MaterialTheme.colorScheme.onBackground.toArgb()

    val markwon = remember {
        Markwon.create(context)
    }

    AndroidView(
        modifier = modifier,
        factory = { ctx ->
            TextView(ctx).apply {
                movementMethod = LinkMovementMethod.getInstance()
                setTextIsSelectable(true)
                setTextColor(textColor)
            }
        },
        update = { textView ->
            markwon.setMarkdown(textView, markdown)
        }
    )
}

This approach means:

  • Smaller footprint: Markwon adds only ~200KB vs WebView’s multi-megabyte overhead
  • Better performance: Native rendering is faster and more memory-efficient
  • Authentic Android feel: Text is selectable, links are clickable, and it respects your system theme automatically

Minimal Dependencies

The entire app uses only essential libraries:

  • Jetpack Compose (built into modern Android)
  • Markwon for markdown rendering
  • Gson for JSON serialization
  • Standard Android libraries

No heavy frameworks, no unnecessary abstractions. Manual dependency injection instead of Dagger/Hilt. SharedPreferences instead of a full database. Each decision prioritizes simplicity and size.

The result? The debug build is around 17MB—and that’s before optimization. For comparison, many note-taking apps exceed 100MB.

Architecture Without Bloat

Under the hood, LightMarkdownReader follows clean MVVM (Model-View-ViewModel) architecture:

  • UI Layer: Modern Jetpack Compose for the interface
  • ViewModel: Manages state and business logic using Kotlin StateFlow
  • Data Layer: Handles file I/O and recent files persistence

This separation means the code is maintainable and testable, but it doesn’t require heavyweight frameworks to achieve it. Good architecture doesn’t have to mean bloat.

How the App Works

The User Experience

Using LightMarkdownReader is refreshingly simple:

  1. Open a file: Tap the “Open File” button, which launches Android’s familiar file picker
  2. Read: Your markdown is rendered beautifully with proper formatting—headers, lists, code blocks, links, bold, italic, all supported
  3. Return anytime: The app automatically tracks your 6 most recently opened files for quick access

That’s it. No account creation, no onboarding tutorials, no feature discovery. Just open and read.

The interface follows Material Design 3 guidelines, which means:

  • It automatically matches your system theme (light or dark mode)
  • The design feels native to Android
  • Edge-to-edge display for an immersive reading experience

The Technical Implementation

File Access: The app uses Android’s Storage Access Framework (SAF), which provides secure access to files wherever they live—local storage, SD card, or cloud storage providers like Google Drive. When you grant permission to a file, the app uses persistent URI permissions to maintain access even after you close it.

Recent Files: Your recently opened files are stored locally using SharedPreferences (serialized with Gson). The app validates each file before displaying it—if you’ve deleted a file or revoked permissions, it’s automatically cleaned from the list.

State Management: The app uses Kotlin’s StateFlow for reactive UI updates. The current state is one of:

  • Empty (no file loaded)
  • Loading (reading file)
  • Success (displaying content)
  • Error (with specific error types: file not found, permission denied, file too large, etc.)

Performance Safeguards: Files are validated before reading with a 10MB size limit. Reading is done through buffered streams with proper resource management. Large files render quickly because native TextView is optimized for text display.

Key Features That Matter

While the app is minimal, it’s not spartan. It includes thoughtful features that enhance the core experience:

  • Rich markdown support: Headers, lists (ordered and unordered), code blocks, inline code, links, bold, italic, blockquotes, and more
  • File sharing: Share markdown files directly from the app using Android’s standard share intent
  • Smart auto-load: Automatically opens your most recent file when you launch the app
  • Persistent permissions: Maintains access to your files across app restarts
  • Comprehensive error handling: Clear, actionable error messages when something goes wrong
  • Theme support: Seamlessly switches between dark and light modes with your system

Each feature serves the core mission: making markdown reading effortless.

The Philosophy Behind It

LightMarkdownReader embodies a simple philosophy: purpose-built tools are better than Swiss Army knives.

In an era where every app wants to be a platform, where “growth” means adding features until the original purpose is buried, there’s value in tools that do one thing exceptionally well. You don’t need an app that’s also a cloud storage provider, a collaboration platform, and a project management system. Sometimes you just need to read a markdown file.

This philosophy extends to the technical implementation:

  • Native platform integration: Use Android’s built-in file picker, share system, and UI components rather than reinventing them
  • Respect user resources: Don’t waste storage, battery, or memory on features users didn’t ask for
  • Stay focused: Resist scope creep and feature bloat

The app is also open source on GitHub, which means you can see exactly how it works, contribute improvements, or fork it for your own needs.

Lightweight Doesn’t Mean Feature-Poor

Here’s what I’ve learned building LightMarkdownReader: being lightweight isn’t about doing less, it’s about doing things thoughtfully.

Every technical decision—from choosing native rendering over WebView, to using manual dependency injection, to storing recent files in SharedPreferences—was made with intention. The goal wasn’t to build the smallest possible app, but to build an app that respects your device and your time.

The result is an app that:

  • Starts instantly
  • Renders markdown beautifully
  • Uses minimal resources
  • Provides a polished experience
  • Stays out of your way

It proves that thoughtful design and smart technical choices can deliver a great user experience without the bloat.

If you work with markdown files and want a simple, fast reader for your Android phone, give LightMarkdownReader a try. It’s available on GitHub, and contributions are always welcome.

Sometimes the best tool for the job is the one that just works—no more, no less.

Updated:

You May Also Enjoy

Test Post

less than 1 minute read

Testing testing… is this thing on?