r/JetpackCompose

I developed Weather World because I wanted a simpler, more helpful way to stay ahead of the forecast. I truly believe that a weather app should be a tool that makes your life easier, not a source of distraction with ads and confusing menus.

How it helps you: The core of the app is all about visual clarity. I’ve focused on creating intuitive graphs that let you see temperature shifts and precipitation trends at a single glance. Instead of reading through long lists of numbers, you can visualize exactly how your day will unfold. It’s minimalist, lightweight, and built for speed—perfect for anyone who values a clean Android experience.

I’d love your support! Please give it a try and see if it helps your daily routine. If you find it useful, please recommend it to your friends! As a solo developer, your support and word-of-mouth are what help me improve and grow.

In compliance with the community rules, I’ve shared the link via IndieAppCircle. Check it out there and let me know what you think!

Find it here: https://play.google.com/store/apps/details?id=com.danie.pocasisveta

Hi,

I built goldr, a server-first Go framework for building templ + HTMX web applications. I created it because I wanted the structure and ergonomics of a modern web framework, but without moving my app into SPA, hydration, or client-state territory. I'm already using Goldr in production, and the main goal is to keep Go web apps easy to see, run, debug, and ship as they grow.

Repo: https://github.com/mobiletoly/goldr

Goldr gives you:

• filesystem routes under app/routes
• route-local pages, HTMX fragments, and POST actions
• nested layouts based on the route tree
• reusable mounted route subtrees, so the same workflow can live in multiple parts of an app without copying route folders
• generated URL helpers, so templates and redirects do not copy path strings
• visible HTMX in .templ files
• live reload with route generation, templ generation, app restart, asset fingerprinting, and browser reload
• fingerprinted and embedded static assets using simple directory conventions
• CLI inspection for routes, layouts, HTMX references, and packaged assets
• a browser visual inspector that can outline which layout, page, fragment, or labeled component produced a page region

The part I like most is that the app still feels like a Go app. Goldr does not own your server, middleware, auth, sessions, database layer, asset compiler, deployment, or client state. It gives structure around the boring repeated parts while leaving application policy explicit.

A route tree looks like this:

app/routes/
  layout.go
  layout.templ
  route.go
  page.templ
  users/
    route.go
    page.templ
    frag_table.templ
    by_id/
      route.go
      page.templ

Goldr turns that into generated net/http dispatch and URL helpers, while the source files stay ordinary Go and templ.

Goldr is still pre-v1, so APIs may change, but it is already useful enough that I'm using it for real production work.

Repo: https://github.com/mobiletoly/goldr

Hey everyone,

When building Android apps with Jetpack Compose, settings screens can quickly become complex. I often found myself writing repetitive code just to keep the UI consistent across different sections, and I realized I needed a unified, structured way to build these screens.

To solve this, I built an open-source library which I just published to Maven Central. It uses a clean, declarative Kotlin DSL that completely removes the friction of building deep, interactive settings menus, allowing you to define your structure quickly and consistently.

Beyond just cleaning up the code, I wanted to solve the visual inconsistencies that often plague custom settings screens. I really enjoy focusing on UX/UI design and fluid animations, so I built the library around the modern Material 3 Expressive aesthetic. It natively handles the heavy lifting for UI details. For instance, it dynamically calculates adaptive corner rounding based on an item's position within a group, and it integrates shared element transitions for a native-feeling navigation between nested screens.

The library comes with over 20 customizable components right out of the box, like keyword editors, range sliders, expandable groups and more classic ones like sliders, checkboxes and switches.

You can find the repo, setup instructions, and a full component catalog in the Wiki here: https://github.com/JulesPvx/compose_unified_material_expressive_settings

Feedback and PRs are highly welcome!

Here is a quick look at how easy it is to set up a group:

LazyColumn(modifier = Modifier.fillMaxSize()) {
    settingsSection(title = "App Preferences") {
        switch(
            title = "Dark Mode",
            checked = isDarkMode,
            onCheckedChange = { isDarkMode = it },
            icon = { Icon(Icons.Default.Brightness4, null) }
        )
        
        selector(
            title = "Language",
            options = listOf("English", "French", "Spanish"),
            selectedOption = language,
            onOptionSelected = { language = it }
        )
        
        link(title = "Privacy Policy", onClick = { /* ... */ })
    }
}

I want that iOS effect where the top header blurs/darkens/dissolves as content scrolls under it. I’ve tried Haze and a few other public repos but none satisfied me. Is this possible in Compose?

I've been thinking about the idea of bringing AOP (like AspectJ/Spring AOP) into the Jetpack Compose ecosystem. The concept is, Just adding an annotation to a composable function to implicitly trigger underlying logic.

@SomeLogic //It triggers to put declared logic
@Composable
fun SomeText() {}

(This is current implementation now.https://github.com/Mole-Labs/aspectkIf it violates rules, I'll remove the link)

​Do you think a dedicated AOP tool would actually solve pain points for Android developers or trailing lambda is already enough for it?

If yes, what specific use cases (besides standard logging/analytics) do you think would justify using AOP in Compose?