GitHub Integration

Integrating GitHub into your Aurora project ensures you have full version control, collaboration tools, and code portability throughout your app’s lifecycle.

​

Quick Start

TL;DR: Connect your GitHub in 3 steps:

1. Go to Settings → Integrations → GitHub and click Connect GitHub
2. Authorize the Aurora GitHub App and install it on your account or organization
3. Toggle “Use for new projects” to create repositories under your GitHub instead of Aurora’s

That’s it! New projects will now be created in your connected GitHub account with full commit history.

​

What is GitHub

Git is a version control system that tracks changes in your code. GitHub is the industry-standard platform for hosting Git repositories, making it essential for both solo builders and teams using Aurora. By linking your project to GitHub, every change in your Aurora app is backed up in a Git repository in real time. This means you get a complete history of your code, the ability to collaborate with developers in familiar workflows, and the freedom to host or deploy your app outside of Aurora if needed. GitHub integration brings transparency, safety, and flexibility to your Aurora development process.

​

Key Benefits of GitHub Integration

Aurora backs every project with a Git repository, making it easy for developers to push commits directly to GitHub. This means: Version History & Backup
All your code is tracked with Git, so you can review changes or roll back to any previous state. Every commit is saved to GitHub, providing an external backup of your project. Team Collaboration
Your code lives on GitHub where others (developers, contributors) can easily view it, comment, and contribute via pull requests. Non-technical team members can also see the code history for transparency. Real-Time Sync
Aurora automatically syncs with your GitHub repo. If you push code to GitHub, Aurora pulls it in almost immediately. If you edit code in Aurora, it pushes those changes to GitHub. You’ll always have the latest code in both places without manual copying. Workflow Integration
Use GitHub’s tools (branches, pull requests, issues, CI/CD, etc.) alongside Aurora. For example, you can run tests or deploy your app via GitHub Actions when code is merged, all while continuing to use Aurora’s editor and AI to develop features. Deployment Flexibility
Connecting to GitHub gives you the option to host your app on your own infrastructure or platform of choice. You’re not locked into Aurora’s hosting – you can export the code and deploy it anywhere.

​

Connecting Aurora to Your GitHub Account

To start using GitHub with Aurora, you need to connect your GitHub account. Here’s how to set it up:

​

How Repository Creation Works

When you create a new Aurora project with GitHub integration enabled:

1. Aurora creates a new repository in your connected GitHub account
2. The repository is initialized with your project’s starter code
3. All subsequent changes made through Aurora are automatically committed and pushed
4. Commits appear as verified and authored by the Aurora GitHub App

​

Aurora-Owned vs Personal GitHub

Aurora offers two modes for repository ownership: Aurora-Owned (Default)
If you haven’t connected GitHub or have the toggle disabled, Aurora creates and manages repositories under Aurora’s GitHub organization. You still get full Git history and can view the code, but the repo lives in Aurora’s account. Personal GitHub
When you connect your GitHub and enable “Use for new projects,” repositories are created directly in your GitHub account or organization. You have full ownership and control, including the ability to add collaborators, configure branch protection, and use GitHub Actions.

​

How Syncing Works (Aurora ↔ GitHub)

Once your project is connected to GitHub, Aurora ensures that code changes stay in sync between the Aurora editor and your GitHub repository. The integration is bidirectional:

​

Default Branch Sync Only

Aurora currently tracks only the default branch of your GitHub repository (typically main). If you push commits to other branches on GitHub, those changes will not appear in your Aurora project until they are merged into the default branch.

​

Real-Time Updates from GitHub

When you commit and push code to the default branch on GitHub, Aurora detects the changes via webhooks and pulls the latest commit into the project. You don’t need to manually refresh or import anything; the editor will reflect the new code typically within a few seconds of the push.

​

Pushing Changes from Aurora

When you make changes in Aurora (editing code directly or having the AI generate new code), those changes are committed and pushed to GitHub automatically. Each change appears in your repository’s commit history with a clear message describing what was modified.

​

Conflict Handling

Because both Aurora and GitHub can change the code, there’s a chance of a git conflict if changes happen on the same file at the same time. If a conflict occurs, you would resolve it like any Git conflict – go to the GitHub repo, manually merge or fix conflicting changes, then commit. Aurora will pull the resolved code.

​

Developing with GitHub and Aurora in Parallel

Once connected, you can build and edit your application using GitHub (or your local development environment) and Aurora simultaneously:

​

Using Your Local IDE

Clone the GitHub repository to your local machine and open it in your favorite IDE (VS Code, WebStorm, etc.). Make changes, commit, and push to GitHub. Aurora will automatically sync those changes.

​

Normal GitHub Workflows

You can leverage all of GitHub’s collaboration features: create branches for new features, open pull requests to review code before merging, file issues, and use project boards. Aurora watches the default branch for changes and syncs when you merge.

​

Combining AI and Manual Coding

Use Aurora’s AI assistant to scaffold features quickly, then refine the code in your IDE. Both sets of changes merge seamlessly since they’re going to the same repository.

​

Importing an Existing GitHub Repository

Currently, Aurora does not support directly importing or linking to an existing external GitHub repository as a new project. However, there are workarounds:

​

Manual Import via New Repo

1. Create a new Aurora project with GitHub integration enabled
2. Clone the newly created repository to your local machine
3. Copy your existing project files into the cloned repo
4. Commit and push the changes
5. Aurora will sync the files and display them in the editor

​

Planned Import Feature

Direct repository import is a commonly requested feature and is under consideration for future updates. Check Aurora’s roadmap for announcements.

​

Documenting Changes and Rolling Back

​

Use Meaningful Commit Messages

When committing via your local IDE or GitHub’s interface, write clear commit messages describing what you changed and why. Good commit messages help team members understand the history of the project.

​

Aurora’s Version History

Aurora provides a version history in the editor that keeps track of changes made through the platform. You can access previous states of your project and restore an earlier version with one click.

​

Rolling Back with Git

Since your project is under Git, you can perform rollbacks by reverting commits on GitHub. Use the “Revert” button on GitHub or git revert locally. Aurora will sync the revert commit automatically.

​

Use Branches for Big Changes

Develop major features on separate branches and only merge to main after testing. This keeps your main branch (and the live app in Aurora) stable.

​

Troubleshooting & FAQ

---

By following this guide and utilizing GitHub with Aurora, you’ll combine the speed of AI-assisted development with the reliability and control of traditional software practices. This integration is designed to be approachable for non-technical users while providing all the power that developers expect in a modern toolchain.