ANIMA

a local social platform that connects people with cultural events happening around them.

Comment

Inspiration

ANIMA is the Italian word for soul. We built this project because we believe culture is what gives a city its pulse. Without local music, art, street markets, and regional food, a city is just concrete, traffic, and a repetitive daily grind.

Right now, local culture has a serious visibility problem. You could be sitting at home or working at your desk while an amazing exhibition or show is happening two blocks away, and you’d never know. To find out what's happening around you, you currently have to follow dozens of random Instagram accounts, hope you catch an ad on local radio, or just get lucky enough for someone to invite you (not in the sad way, we promise!).

We made ANIMA to fix this. It’s a space built to make local culture accessible to everyone, giving artists a place to be seen and helping people actually live in their city instead of just passing through it.

What it does

ANIMA connects local creators with people looking for something real to do in their city through two straightforward roles:

Visitor Flow

  • Feed & Discovery: Browse local events categorized by "Happening Now", "Events I'm Attending", and "Following". Users can filter events by location, date, or category.

  • Event Details: Check out dates, exact locations, rules, and schedules (whether it's a one-time thing or a recurring event). You can see real-time updates on event status (ongoing, upcoming, postponed, or canceled).

  • RSVP: Tap once to mark "I'm going". This automatically saves the event to your personal "Events I'm Attending" tab so you don't miss it.

Expositor (Organizer) Flow

  • Create Events: Post cultural events with details, rules, schedules, categories, and location tags.

  • Dashboard: Manage active events and update their status in real time (e.g., changing an event from upcoming to ongoing, postponed, or canceled).

  • Expositor Profile: Account verification for organizers to build trust with the community, alongside a dedicated host feed view.

How we built it

We built ANIMA with a decoupled, feature-first architecture to keep the codebase clean and maintainable as the app grows:

  • Backend: Kotlin with Spring Boot, handling our REST API and business logic. All database operations are locked behind the backend, running on PostgreSQL.

  • Mobile App: Built using Compose Multiplatform with an MVVM pattern and StateFlow for state management. Client-side dependency injection is handled by Koin.

  • Custom Design System: We chose not to use default MaterialTheme UI components. Instead, we built our own design system from scratch using local tokens (core.theme) for colors, typography, spacing, and border radius. Our global icon component renders SVGs directly from Lucide Icons.

  • Localization: Set up using composeResources with built-in support for English (default), Portuguese, and Spanish based on system language.

  • Infrastructure: Hosted on Google Cloud Run and Firebase (analytics and web hosting). We enforced standard Git practices using type/module/label branching and Conventional Commits.

Challenges we ran into

  • Backend Migration: Switching our backend strategy to Spring Boot mid-way meant refactoring our architecture and API integration while keeping Kotlin models aligned.

  • Building UI from Scratch: Ditching default Material components gave us complete visual freedom, but it meant building every button, card, and layout component ourselves in Compose.

  • Feature-First Discipline: Keeping the code separated into clear layers (data, domain, and presentation) took constant discipline to ensure feature modules remained truly independent.

Accomplishments that we're proud of

  • Our Own Design System: Achieving a unique, cohesive visual identity that feels custom-built for ANIMA rather than a generic template.

  • Clean Kotlin Integration: Connecting a Spring Boot backend smoothly with a Compose Multiplatform app without sacrificing clean code standards.

  • Solving a Real Problem: Building a working tool aimed at solving an issue we personally experience in our hometown every day.

What we learned

  • Modular Architecture: How to properly structure a feature-first Kotlin project to separate domain logic from UI and data layers.

  • Design Token System: How building custom color, spacing, and typography tokens early on saves time when constructing UI screens.

  • Spring Boot + Kotlin: Best practices for writing clean REST endpoints using Spring Boot in a Kotlin environment.

What's next for ANIMA

  • Interactive Map: Adding a visual map to find street fairs and outdoor events near you.

  • Direct Organizer Contacts: Allowing organizers to link their direct social media/contact channels on event pages.

  • Push Notifications: Alerting users via Firebase when an event they saved is about to start.

  • Community Feedback: Adding reviews, ratings, and reporting tools to build trust across the community.

Share this project:

Updates

Submission history