Profile Information

Name: Gautham Mohanraj
Github: https://github.com/angrezichatterbox
College: Amrita Vishwa Vidyapeetam, Amritapuri
Major: Bachelors in Computer Science Engineering
Country: India
Timezone: IST(UTC+5:30)
Working Hours: 19:00 - 24:00 IST
Mentor(s): @AndrewTavis, @Henrikt93 , @DeleMike

Synopsis

This project introduces Conjugate, a new mobile application for both Android and iOS that provides a free, open-source, and privacy-respecting verb conjugation tool powered by Wikidata. It offers a strong alternative to existing apps that are often paid, ad-heavy, or collect user data.

By focusing on a simple and intuitive interface, the app lowers the barrier for language learners, making it easier for beginners to explore verb forms across multiple languages while still being useful for advanced users.

From a community standpoint, this project expands the Scribe ecosystem beyond keyboard applications, demonstrates practical use of Wikidata’s lexicographical data in mobile apps, and encourages further open-source contributions. Overall, it helps make language learning tools more accessible, transparent, and aligned with Wikimedia’s open knowledge mission.

Possible Mentor(s): @AndrewTavis, @Henrikt93 , @DeleMike
Have you contacted your mentors already?: Yes

Deliverables

General

• Show timely and consistent work throughout.
• Document changes and the reasons behind them.
• Create GitHub issues to establish project management workflows.
• Communicate GSoC milestones via Phabricator and other means.

Before Mid-term Evaluation

• Complete the various UI elements of the Conjugate application for both Android and iOS. This would include polishing the the various changes that have occurred during the contribution period.
• Make sure that the Scribe-Android and Scribe-iOS application autocomplete and autosuggestion works properly and could be moved to release.
• Modularise the application to make sure that the common components are being kept together and the individual components used by the individual apps are not being added to the codebase of both the apps increasing the size of the app builds.

Before Final Evaluation

• Use the data from the SQLite databases for adding autocompletion for searching of Conjugate words and also integration with the Conjugation view.
• Do test-driven development for the Conjugate application while the shared components tests are written so that we would have a great codebase and the project would be setup for better contributions for the future.

Timeline

Community Bonding Period

Since I am already familiar with the Scribe ecosystem, I will use this period primarily to align closely with mentors and finalise the implementation plan.

I will:

• Discuss project scope, MVP, and milestones in detail
• Review the Scribe-iOS codebase to understand existing UIKit components
• Get up to speed with SwiftUI and its integration with UIKit
• Finalise a development workflow with regular check-ins and documentation

Week 1

• Deep dive into Scribe-Android
• Identify reusable components and integration points
• Plan architecture for integrating new Conjugate features with minimal duplication

Week 2–3

• Implement core Android UI components using existing infrastructure
• Integrate SQLite database with:
  • Verb search
  • Autocomplete
• Build initial version of the conjugation view

Week 4–5 (Mid-term Evaluation)

• Complete Android features:
  • Stable autocomplete and search
  • Conjugation table with filtering
• Ensure features are optimised and releasable
• Begin modularisation of reusable components
• Start SwiftUI-based iOS setup

Week 6–8

• Develop iOS Conjugate app using SwiftUI
• Recreate components in SwiftUI
• Implement SwiftUI ↔ UIKit interoperability where required
• Integrate SQLite database with iOS UI

Week 9–10

• Complete iOS features and ensure feature parity with Android
• Optimise performance and responsiveness
• Improve cross-platform consistency

Week 11

• Perform extensive testing across both platforms
• Fix bugs and edge cases
• Validate multi-language database usage

Week 12–13

• Add tests for database and core logic
• Final optimisations and documentation
• Buffer time for improvements and mentor feedback

Participation

• GitHub issues will be created for task tracking
• Regular commits with clear documentation
• Progress updates via Phabricator

About Me

I am a third-year student from India with a strong passion for mobile application development. I enjoy building applications that create a meaningful social impact, as it gives me a deep sense of satisfaction. Beyond coding, I enjoy reading books and watching movies and TV shows.

I am proficient in Kotlin and Java with experience developing Mobile apps in cross platforms frameworks like flutter and native application using Android SDK and Jetpack components. I am comfortable working with REST APIs, handling asynchronous operations, and designing user-centric mobile interfaces. I also have a strong understanding of using Git and GitHub.

Past Experience

I started contributing to Scribe-Android during my mid semester in June 2024. During those days Scribe-Android projects had just started and I had started to implement some of the core functions of the keyboard that were missing from its port of Simple Keyboard. This gave me a good idea of the deep workings of the AOSP Keyboard. Ever since then I gained further understanding of the project after contributing for over an year or two and have been a consistent contributor to the project. I was able to mentor for the project at the Wikimedia Hackathon Kochi last year where I was able to guide people to contribute to the project. Earlier this year I tried to pivot towards the iOS project and was able to get some contributions to get a brief understanding of the iOS project.

Micro-tasks completed during the application period

Reviews:

https://github.com/scribe-org/Scribe-Android/pull/578
https://github.com/scribe-org/Scribe-Android/pull/576

PR:

https://github.com/scribe-org/Scribe-iOS/pull/604
https://github.com/scribe-org/Scribe-Android/pull/592

Any Other Info

Design References (Figma)

Figma Link: https://www.figma.com/design/c8945w2iyoPYVhsqW7vRn6/scribe_public_designs?node-id=405-393

Technical Proposal

My approach to the project deliverables is structured into the following main components:

1. Conjugate Application UI (Android and iOS)

The Conjugate application will be developed for both Android and iOS, following the designs provided in Figma, while taking different implementation approaches based on the current state of each codebase.

On Android, development will be relatively streamlined as it builds upon the existing Scribe-Android application. I will reuse existing components such as UI elements, data handling layers, and architecture patterns wherever possible. Only the new features specific to the Conjugate application (such as the conjugation view, verb search, and filtering UI) will be implemented as new components. This allows faster development while maintaining consistency with the existing app.

On iOS, the approach will involve a more significant refactor. All components for the Conjugate application will be developed using SwiftUI, requiring a rewrite of existing UIKit-based components where necessary. This provides an opportunity to modernize the codebase and improve maintainability.

To ensure smooth integration:

• I will explore interoperability between SwiftUI and UIKit, allowing gradual migration rather than a complete rewrite at once.
• Shared or commonly used screens between Scribe-iOS and Conjugate-iOS will be progressively migrated to SwiftUI where feasible.
• Navigation and UI structure will be designed to support both SwiftUI-based views and existing UIKit components during the transition phase.

2. Data Integration using SQLite

The conjugation data is already available as prebuilt SQLite databases, which can be downloaded within the application through the existing language data download interface. My focus will be on integrating these databases into the application and efficiently using them to power core features.

I will implement a data access layer that works directly with the downloaded SQLite files to support:

• Verb search
• Autocomplete suggestions
• Conjugation view rendering

This involves:

• Handling the download and local storage of SQLite databases for selected languages
• Establishing connections to the databases and querying them efficiently
• Writing optimised SQL queries for fast prefix-based search and filtering
• Seamlessly connecting query results to UI components such as search and conjugation views

Additionally, I will ensure that the system supports multiple language datasets in parallel, allowing users to switch or query across languages without performance degradation.

The primary goal is to bridge the downloaded SQLite data with the application’s UI and logic, ensuring a smooth, responsive, and scalable user experience without modifying the existing data generation pipeline.

3. Autocomplete & Search System

Autocomplete is a core feature of the application.

• Implement prefix-based search using indexed SQLite queries
• Provide real-time suggestions as the user types
• Support multilingual search across downloaded language datasets

To optimize performance:

• Use debouncing for input handling
• Cache recent queries

This system will be made production-ready before the final evaluation.

4. Conjugation View Implementation

The conjugation view will display verb forms in a structured and scrollable format.

• Data will be dynamically fetched from SQLite
• UI will support filtering by tense
• Each cell in the conjugation table will be clickable to copy values to clipboard

Efficient rendering techniques (LazyColumn on Android, SwiftUI counterpart on iOS) will be used to handle large datasets.

5. Modularisation of Codebase

To avoid duplication and reduce app size:

• Shared logic (data models, database handling, parsing) will be modularised
• Platform-specific UI logic will remain isolated
• Common components will be reused across features

This ensures:

• Smaller build sizes
• Easier maintainability
• Cleaner separation of concerns

6. Test-Driven Development (TDD)

A test-driven approach will be followed throughout development of the Conjugate Application

• Unit tests for database queries and business logic
• Tests for autocomplete functionality
• Validation of data parsing and transformations

Shared components will have dedicated tests to ensure consistency across Android and iOS.

7. Project Workflow & Communication

Development will be carried out in a structured and transparent manner:

• GitHub issues will be created for task tracking
• Regular commits with clear documentation
• Progress updates via Phabricator

Potential Personal Takeaways

Since I already have experience contributing to Scribe, this project will help me deepen my understanding of the ecosystem, particularly on the iOS side and data integration layer.

I aim to:

• Gain practical experience with SwiftUI and UIKit interoperability
• Strengthen my ability to work with SQLite-driven applications at scale
• Improve my understanding of cross-platform architecture and modular design

Additionally, this project will help me grow in terms of writing production-quality code, collaborating in an open-source environment, and making architectural decisions that impact real users.