How the 'Fediverse' Works (and Why It Might Be the Future of Social Media)
https://lifehacker.com/tech/what-is-the-fediverse-the-potential-future-of-social-media

https://redd.it/1mlqsom
@r_opensource

wrkflw v0.6.0

Hey everyone!

Excited to announce the release of wrkflw v0.6.0! 🎉

For those unfamiliar, wrkflw is a command-line tool written in Rust, designed to help you validate, execute and trigger GitHub Actions workflows locally.

# What's New in v0.6.0?

🐳 Podman Support: Run workflows with Podman, perfect for rootless execution and environments where Docker isn't permitted!

Improved Debugging: Better container preservation and inspection capabilities for failed workflows.

# Install and try it out!
cargo install wrkflw

# Run with Podman
wrkflw run --runtime podman .github/workflows/ci.yml

# Or use the TUI
wrkflw tui --runtime podman

Checkout the project at https://github.com/bahdotsh/wrkflw

I'd love to hear your feedback! If you encounter any issues or have suggestions for future improvements, please open an issue on GitHub. Contributions are always welcome!

Thanks for your support!

https://redd.it/1mlqkie
@r_opensource

MBCompass - FOSS Compass and Navigation App

Hello everyone,

I'm excited to share MBCompass, which is a modern, free, and open source Compass and Navigation app without Ads, IAP, or Tracking.

That's support Compass and Navigation features with being lightweight and simple!

I built MBCompass, not just another FOSS compass app; it bridges the gap between a **compass** and a **full navigation app**

[https://github.com/CompassMB/MBCompass](https://github.com/CompassMB/MBCompass)

Features:

* Shows clear cardinal direction and magnetic azimuths.
* Displays magnetic strength in µT.
* Live GPS location tracking on OpenStreetMap.
* Sensor fusion for improved accuracy (accelerometer, magnetometer, gyroscope).
* Light and dark theme support is controlled via Settings.
* Keeps the screen on during navigation.
* Landscape orientation support.
* Built with Jetpack Compose and Material Design.
* No ads, no in-app purchases, no tracking.
* Runs on Android 5.0+
* full list available on website

**Even with all these features, MBCompass was just 1.35MB APK size with no ads, no IAPs, and no trackers**

For more info: [https://compassmb.github.io/MBCompass-site/](https://compassmb.github.io/MBCompass-site/)

https://redd.it/1mlpp6c
@r_opensource

QFlow Workflow and Agent automation
https://www.npmjs.com/package/@fractal-solutions/qflow

https://redd.it/1mlvomz
@r_opensource

Debian 13 "trixie" released
https://www.debian.org/News/2025/20250809

https://redd.it/1mlx629
@r_opensource

I have built Runtime: skills-based browser automation that uses fewer tokens

Hi HN, I’m tito. I’m launching Runtime — a desktop tool that automates your existing browser using small, reusable skills instead of big, fragile prompts.

Why did I build it?

I was using browser automation for my own work, but it got slow and expensive because it pushed huge chunks of a page to the model. I also saw agent systems like browser-use that try to stream the live DOM/processed and “guess” the next click. It looked cool, but it felt heavy and flaky.

I asked a few friends what they really wanted to have a browser that does some of their jobs, like repetitive tasks. All three said: “I want to teach my browser or just explain to it how to do my tasks.” Also: “Please don’t make me switch browsers—I already have my extensions, theme, and setup.” That’s where Runtime came from: keep your browser, keep control, make automation predictable

Runtime takes a task in chat (I’m open to challenging the User experience of conversing with runtime), then runs a short plan made of skills. A skill is a set of functions: it has inputs and an expected output. Examples: “search a site,” “open a result,” “extract product fields,” “click a button,” “submit a form.” Because plans use skills (not whole pages), prompts stay tiny, process stays deterministic and fast.

Links

* README: [https://github.com/runtime-org/runtime/blob/main/README.md](https://github.com/runtime-org/runtime/blob/main/README.md) 
* Skills guide: [https://github.com/runtime-org/runtime/blob/main/SKILLS.md](https://github.com/runtime-org/runtime/blob/main/SKILLS.md)

What’s different

* Uses your browser (Chrome/Edge, soon Brave). No new browser to install.
* Deterministic by design. Skills are explicit and typed; runs are auditable.
* Low token use. We pass compact actions, not the full DOM. And most importantly, we don’t take screenshots at all. We believe screenshots are useless if we use selectors to navigate.
* Human-in-the-loop. You can watch the steps and stop/retry anytime.

Who it's for?

People who do research/ops on the web: pull structured info, file forms, move data between tools, or run repeatable flows without writing a full RPA noscript or without using any API. It’s just “runtime run at runtime”

Try this first (5–10 minutes)

1. Clone the repo and follow the quickstart in the README.
2. Run a sample flow: search → open → extract fields.
3. Read \`SKILLS.md\`, then make one tiny skill for a site you use daily.

What’s not perfect yet

Sites change. Skills also change, but we will post about addressing this issue.

I’d love to hear where it breaks.

Feedback I’m asking for:

* Is the skills format clear? Being declarative, does that help?
* Where does the planner over-/under-specify steps?
* Which sites should we ship skills for first?

Happy to answer everything in the comments, and would love a teardown. Thanks!

Tito

https://redd.it/1mm0bsy
@r_opensource

What features would you want in an open source learning app?

Hey r/opensource,

I’ve been working on a project called Mnemo for 2 years now, a free and open source study app aimed at making learning tools accessible to everyone. The programming started two weeks ago (no downloads yet), but the website is up with details, UI showcase, and the philosophy behind it: https://shadowccs.github.io/mnemo-site/

The big ideas behind Mnemo are:

No expensive subnoscriptions for basic learning tools
Fully open source & customizable
Private by default, your data stays with you
Feature development guided by learners, not corporate priorities

I’d love your thoughts on:

Is this something you’d find useful?
What features would you want in a study tool like this?
Anything that feels missing from the concept?
Anything specific you find lacking from other tools?

This isn’t meant as a promo, more like a sanity check before I dive deep into coding.
I really want feedback from people who value open source principles.

Thanks for reading!

https://redd.it/1mm2roi
@r_opensource

Sonatype moved from the Eclipse Public Licensed to being closed source and proprietary in a point release from 3.76 to 3.77 with no means to rollback
https://battlepenguin.com/tech/fixing-yum-indexing-on-sonatype-nexus-and-the-non-opensource-upgrade/

https://redd.it/1mm5oje
@r_opensource

I'm new to open source. What open source license would you recommend?

I have a project I'm building and trying to figure out what is the best license to use for open source any recommendations or considerations?

https://redd.it/1mm7wp1
@r_opensource

We just made Loadouts for Genshin Impact available as an RPM package in the official Fedora Linux repositories - v0.1.10 being the first release there!

# TLDR

Besides its availability as a [*repository package on PyPI*](https://pypi.org/project/gi-loadouts/?ref=gridhead.net) and as an [*archived binary on PyInstaller*](https://github.com/gridhead/gi-loadouts/releases/tag/0.1.10?ref=gridhead.net), Loadouts for Genshin Impact is now available as an [*installable package on Fedora Linux*](https://src.fedoraproject.org/rpms/gi-loadouts?ref=gridhead.net). Travelers using [*Fedora Linux 42 and above*](https://bodhi.fedoraproject.org/updates/?search=gi-loadouts&user=t0xic0der&ref=gridhead.net) can install the package on their operating system by executing the following command.

$ sudo dnf install gi-loadouts --assumeyes --setopt=install_weak_deps=False

# About

This is a desktop application that allows travelers to manage their custom equipment of artifacts and weapons for playable characters and makes it convenient for travelers to calculate the associated statistics based on their equipment using the semantic understanding of how the gameplay works. Travelers can create their bespoke loadouts consisting of characters, artifacts and weapons and share them with their fellow travelers. Supported file formats include a human-readable **Yet Another Markup Language (YAML)** serialization format and a JSON-based **Genshin Open Object Definition (GOOD)** serialization format.

This project is currently in its beta phase and we are committed to delivering a quality experience with every release we make. If you are excited about the direction of this project and want to contribute to the efforts, we would greatly appreciate it if you help us boost the project visibility by **starring the project repository**, address the releases by **reporting the experienced errors**, choose the direction by **proposing the intended features**, enhance the usability by **documenting the project repository**, improve the codebase by **opening the pull requests** and finally, persist our efforts by **sponsoring the development members**

Updates

[Loadouts for Genshin Impact v0.1.10](https://gridhead.net/loadouts-for-genshin-impact-v0-1-10-released/) is OUT NOW with the addition of support for recently released characters like **Ineffa** and for recently released weapons like **Fractured Halo** and **Flame-Forged Insight** from **Genshin Impact v5.8 Phase 1**. Take this FREE and OPEN SOURCE application for a spin using the links below to manage the custom equipment of artifacts and weapons for the playable characters.

# Resources

* [Loadouts for Genshin Impact - GitHub](https://github.com/gridhead/gi-loadouts?ref=gridhead.net)
* [Loadouts for Genshin Impact - PyPI](https://pypi.org/project/gi-loadouts?ref=gridhead.net)
* [Loadouts for Genshin Impact v0.1.10](https://github.com/gridhead/gi-loadouts/releases/tag/0.1.10?ref=gridhead.net)
* [Executable for GNU/Linux distributions](https://github.com/gridhead/gi-loadouts/releases/download/0.1.10/gi-loadouts-0.1.10?ref=gridhead.net)
* [Executable for Microsoft Windows](https://github.com/gridhead/gi-loadouts/releases/download/0.1.10/gi-loadouts-0.1.10.exe?ref=gridhead.net)

# Screenshots

* [Ineffa - Workspace](https://gridhead.net/content/images/2025/08/infa_dash.png)
* [Ineffa - Results](https://gridhead.net/content/images/2025/08/infa_rslt.png)
* [Fractured Halo - Workspace](https://gridhead.net/content/images/2025/08/ftho.png)
* [Flame-Forged Insight - Workspace](https://gridhead.net/content/images/2025/08/ffit.png)

# Appeal

While allowing you to experiment with various builds and share them for later, Loadouts for Genshin Impact lets you take calculated risks by showing you the potential of your characters with certain artifacts and weapons equipped that you might not even own. Loadouts for Genshin Impact has been and always be a free and open source software project and we are committed to delivering a quality experience with every release we make.

# Disclaimer

With an extensive

suite of over 1465 diverse functionality tests and impeccable 100% source code coverage, we proudly invite auditors and analysts from MiHoYo and other organizations to review our free and open source codebase. This thorough transparency underscores our unwavering commitment to maintaining the fairness and integrity of the game.

The users of this ecosystem application can have complete confidence that their accounts are safe from warnings, suspensions or terminations when using this project. The ecosystem application ensures complete compliance with the terms of services and the regulations regarding third-party software established by MiHoYo for Genshin Impact.

All rights to Genshin Impact assets used in this project are reserved by miHoYo Ltd. and Cognosphere Pte., Ltd. Other properties belong to their respective owners.

https://redd.it/1mm8g25
@r_opensource

I made a better Political Compass test

Hi guys, I was frustrated when doing the political compass, so I made a cool quiz called Votely.

It’s basically the Political Compass with more accuracy and depth, but still quick to take.

We’ve also been adding more features at the request of our users, including:

1. A progressive to conservative axis to capture social views
2. 81 ideologies instead of just four quadrants
3. percentage sliders from -100% to 100% for nuance
4. a very fun 3D cube you can spin around
5. short and long versions depending on how much time you have

Check it out at https://votelyquiz.juleslemee.com/ and let me know what you think! I’d love feedback on any features you’d like to see next.

The code is fully open source at https://github.com/juleslemee/Votely

https://redd.it/1mm81we
@r_opensource

Useful GitHub template for Git projects and readme.md
https://github.com/dec0dOS/amazing-github-template

https://redd.it/1mmc2cr
@r_opensource

Show HN: I open sourced my screenshot tool that i made for myself.

https://github.com/jellydeck/moocup/


features:

\- 3d transform, scale up and down image

\- Change position, scale

\- Apply fixed margin on all axis

\- Smart magic border, color, width

\- Single click export to Webp, PNG, JPEG.



you can also self-host by following instructions in Readme, or using Railway for single click deploy.

It's a personal tool I made for myself. I needed good photos to showcase my work, and all the available options felt quite right.

so i made one myself.

lemme know if you have any ideas for features.

https://redd.it/1mmcqep
@r_opensource

Open Source to Business – Your Suggestions Needed

Hello folks,

I have developed an open tool designed to assist researchers and academics with article and literature research and search. My question is—how can I best leverage this tool from a business perspective?

My current plan is to launch it as a free tool for now, with frequent updates and new features in the pipeline. I would appreciate any ideas or suggestions you can share.

https://redd.it/1mme31x
@r_opensource

A free, open-source “computer freeze” tool?

I’m keen to hear everyone’s thoughts on building a program that can effectively “freeze” your computer so no changes are written to the drive.

Basically a modern version of Toolwiz Time Freeze (link to Wayback Machine). I have tried to reach the owners, but I can't find any recent contact information. My use case is for when we are sharing devices in a setting where Windows Enterprise is unrealistic.

I know Deepfreeze exists, but I would rather use something free and open source. My primary objective is to get a hold of someone at Timefreeze to ask for the code, but I don't know how realistic this is.

https://redd.it/1mmi00a
@r_opensource

KmpEssentials is a library that contains apis (40+ Modules) to accelerate your development. Everything from managing the Battery, File System, getting Package information, or taking Photos. Supports iOS, Android, AppleWatch, JVM & JS
https://github.com/Ares-Defence-Labs/KmpEssentials

https://redd.it/1mmk3wg
@r_opensource

Pybotchi 101: Simple MCP Integration

# As Client

### Prerequisite

- LLM Declaration

```python
from pybotchi import LLM
from langchain_openai import ChatOpenAI

LLM.add(
base = ChatOpenAI(.....)
)
```

- MCP Server (`MCP-Atlassian`)
> docker run --rm -p 9000:9000 -i --env-file your-env.env ghcr.io/sooperset/mcp-atlassian:latest --transport streamable-http --port 9000 -vv

### Simple Pybotchi Action

```python
from pybotchi import ActionReturn, MCPAction, MCPConnection

class AtlassianAgent(MCPAction):
"""Atlassian query."""

__mcp_connections__ = [
MCPConnection("jira", "http://0.0.0.0:9000/mcp", require_integration=False)
]

async def post(self, context):
readable_response = await context.llm.ainvoke(context.prompts)
await context.add_response(self, readable_response.content)
return ActionReturn.END
```

- `post` is only recommended if mcp tools responses is not in natural language yet.
- You can leverage `post` or `commit_context` for final response generation

### View Graph

```python
from asyncio import run
from pybotchi import graph

print(run(graph(AtlassianAgent)))
```

#### **Result**

```
flowchart TD
mcp.jira.JiraCreateIssueLink[mcp.jira.JiraCreateIssueLink]
mcp.jira.JiraUpdateSprint[mcp.jira.JiraUpdateSprint]
mcp.jira.JiraDownloadAttachments[mcp.jira.JiraDownloadAttachments]
mcp.jira.JiraDeleteIssue[mcp.jira.JiraDeleteIssue]
mcp.jira.JiraGetTransitions[mcp.jira.JiraGetTransitions]
mcp.jira.JiraUpdateIssue[mcp.jira.JiraUpdateIssue]
mcp.jira.JiraSearch[mcp.jira.JiraSearch]
mcp.jira.JiraGetAgileBoards[mcp.jira.JiraGetAgileBoards]
mcp.jira.JiraAddComment[mcp.jira.JiraAddComment]
mcp.jira.JiraGetSprintsFromBoard[mcp.jira.JiraGetSprintsFromBoard]
mcp.jira.JiraGetSprintIssues[mcp.jira.JiraGetSprintIssues]
__main__.AtlassianAgent[__main__.AtlassianAgent]
mcp.jira.JiraLinkToEpic[mcp.jira.JiraLinkToEpic]
mcp.jira.JiraCreateIssue[mcp.jira.JiraCreateIssue]
mcp.jira.JiraBatchCreateIssues[mcp.jira.JiraBatchCreateIssues]
mcp.jira.JiraSearchFields[mcp.jira.JiraSearchFields]
mcp.jira.JiraGetWorklog[mcp.jira.JiraGetWorklog]
mcp.jira.JiraTransitionIssue[mcp.jira.JiraTransitionIssue]
mcp.jira.JiraGetProjectVersions[mcp.jira.JiraGetProjectVersions]
mcp.jira.JiraGetUserProfile[mcp.jira.JiraGetUserProfile]
mcp.jira.JiraGetBoardIssues[mcp.jira.JiraGetBoardIssues]
mcp.jira.JiraGetProjectIssues[mcp.jira.JiraGetProjectIssues]
mcp.jira.JiraAddWorklog[mcp.jira.JiraAddWorklog]
mcp.jira.JiraCreateSprint[mcp.jira.JiraCreateSprint]
mcp.jira.JiraGetLinkTypes[mcp.jira.JiraGetLinkTypes]
mcp.jira.JiraRemoveIssueLink[mcp.jira.JiraRemoveIssueLink]
mcp.jira.JiraGetIssue[mcp.jira.JiraGetIssue]
mcp.jira.JiraBatchGetChangelogs[mcp.jira.JiraBatchGetChangelogs]
__main__.AtlassianAgent --> mcp.jira.JiraCreateIssueLink
__main__.AtlassianAgent --> mcp.jira.JiraGetLinkTypes
__main__.AtlassianAgent --> mcp.jira.JiraDownloadAttachments
__main__.AtlassianAgent --> mcp.jira.JiraAddWorklog
__main__.AtlassianAgent --> mcp.jira.JiraRemoveIssueLink
__main__.AtlassianAgent --> mcp.jira.JiraCreateIssue
__main__.AtlassianAgent --> mcp.jira.JiraLinkToEpic
__main__.AtlassianAgent --> mcp.jira.JiraGetSprintsFromBoard
__main__.AtlassianAgent --> mcp.jira.JiraGetAgileBoards
__main__.AtlassianAgent --> mcp.jira.JiraBatchCreateIssues
__main__.AtlassianAgent --> mcp.jira.JiraSearchFields
__main__.AtlassianAgent --> mcp.jira.JiraGetSprintIssues
__main__.AtlassianAgent --> mcp.jira.JiraSearch
__main__.AtlassianAgent --> mcp.jira.JiraAddComment
__main__.AtlassianAgent --> mcp.jira.JiraDeleteIssue
__main__.AtlassianAgent --> mcp.jira.JiraUpdateIssue
__main__.AtlassianAgent --> mcp.jira.JiraGetProjectVersions
__main__.AtlassianAgent --> mcp.jira.JiraGetBoardIssues
__main__.AtlassianAgent --> mcp.jira.JiraUpdateSprint
__main__.AtlassianAgent --> mcp.jira.JiraBatchGetChangelogs
__main__.AtlassianAgent --> mcp.jira.JiraGetUserProfile
__main__.AtlassianAgent --> mcp.jira.JiraGetWorklog
__main__.AtlassianAgent --> mcp.jira.JiraGetIssue
__main__.AtlassianAgent --> mcp.jira.JiraGetTransitions
__main__.AtlassianAgent -->

mcp.jira.JiraTransitionIssue
__main__.AtlassianAgent --> mcp.jira.JiraCreateSprint
__main__.AtlassianAgent --> mcp.jira.JiraGetProjectIssues
```

### Execute

```python
from asyncio import run
from pybotchi import Context

async def test() -> None:
"""Chat."""
context = Context(
prompts=[
{
"role": "system",
"content": "Use Jira Tool/s until user's request is addressed",
},
{
"role": "user",
"content": "give me one inprogress ticket currently assigned to me?",
},
]
)
await context.start(AtlassianAgent)
print(context.prompts[-1]["content"])


run(test())
```

#### **Result**

```
Here is one "In Progress" ticket currently assigned to you:

- Ticket Key: BAAI-244
- Summary: [FOR TESTING ONLY]: Title 1
- Denoscription: Denoscription 1
- Issue Type: Task
- Status: In Progress
- Priority: Medium
- Created: 2025-08-11
- Updated: 2025-08-11
```

## Override Tools (JiraSearch)

```
from pybotchi import ActionReturn, MCPAction, MCPConnection, MCPToolAction

class AtlassianAgent(MCPAction):
"""Atlassian query."""

__mcp_connections__ = [
MCPConnection("jira", "http://0.0.0.0:9000/mcp", require_integration=False)
]

async def post(self, context):
readable_response = await context.llm.ainvoke(context.prompts)
await context.add_response(self, readable_response.content)
return ActionReturn.END

class JiraSearch(MCPToolAction):
async def pre(self, context):
print("You can do anything here or even call `super().pre`")
return await super().pre(context)
```

### View Overridden Graph

```
flowchart TD
... same list ...
mcp.jira.patched.JiraGetIssue[mcp.jira.patched.JiraGetIssue]
... same list ...
__main__.AtlassianAgent --> mcp.jira.patched.JiraGetIssue
... same list ...
```

#### **Updated Result**

```
You can do anything here or even call `super().pre`
Here is one "In Progress" ticket currently assigned to you:

- Ticket Key: BAAI-244
- Summary: [FOR TESTING ONLY]: Title 1
- Denoscription: Denoscription 1
- Issue Type: Task
- Status: In Progress
- Priority: Medium
- Created: 2025-08-11
- Last Updated: 2025-08-11
- Reporter: Alexie Madolid

If you need details from another ticket or more information, let me know!
```

# As Server

#### **server.py**

```python
from contextlib import AsyncExitStack, asynccontextmanager
from fastapi import FastAPI
from pybotchi import Action, ActionReturn, start_mcp_servers

class TranslateToEnglish(Action):
"""Translate sentence to english."""

__mcp_groups__ = ["your_endpoint1", "your_endpoint2"]

sentence: str

async def pre(self, context):
message = await context.llm.ainvoke(
f"Translate this to english: {self.sentence}"
)
await context.add_response(self, message.content)
return ActionReturn.GO

class TranslateToFilipino(Action):
"""Translate sentence to filipino."""

__mcp_groups__ = ["your_endpoint2"]

sentence: str

async def pre(self, context):
message = await context.llm.ainvoke(
f"Translate this to Filipino: {self.sentence}"
)
await context.add_response(self, message.content)
return ActionReturn.GO

@asynccontextmanager
async def lifespan(app):
"""Override life cycle."""
async with AsyncExitStack() as stack:
await start_mcp_servers(app, stack)
yield


app = FastAPI(lifespan=lifespan)
```

#### **client.py**

```bash
from asyncio import run

from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client


async def main(endpoint: int):
async with streamablehttp_client(
f"http://localhost:8000/your_endpoint{endpoint}/mcp",
) as (
read_stream,
write_stream,
_,
):
async with ClientSession(read_stream, write_stream) as session:
await session.initialize()
tools = await session.list_tools()
response = await session.call_tool(

"TranslateToEnglish",
arguments={
"sentence": "Kamusta?",
},
)
print(f"Available tools: {[tool.name for tool in tools.tools]}")
print(response.content[0].text)


run(main(1))
run(main(2))
```

#### **Result**

```
Available tools: ['TranslateToEnglish']
"Kamusta?" in English is "How are you?"
Available tools: ['TranslateToFilipino', 'TranslateToEnglish']
"Kamusta?" translates to "How are you?" in English.
```


https://redd.it/1mmnr5y
@r_opensource

Good resources for learning about managing open source and open source "business models".

I've started to soft launch my first open source project, which is a niche project tailored for a non-programming community.

I attended an event yesterday and I feel buoyed by the response I got. I had a link to a very basic version of my project at the event. My project was very well received and I feel as if I may be on to something. People seem really stoked. It's only one event, but I feel confident now that I can copy that success in getting buzz, and keep building the project and it will just get better.

I have NEVER done anything like this and I'm trying use this momentum while also building a roadmap in my brain of how to sustain and keep the ball rolling, while also keep the project from sucking.

I'm motivated to go open source rather than commercial because I think it'll be much much easier to build a community this way. There are plenty of commercial alternatives, but not really any stand out open source projects. I'm also a relatively green programmer (competent, but not a wizard. ~5 YOE building stuff).

The few questions on my mind now that I'm slowly making the idea public:

-Competiveness. Because it's open source, anyone can use and modify my code. Obviously this is a really neat part of open source. I also can't help shake the quiet instinct saying "what if someone steals it and builds something better and I get left out" or whatever.

-Monetization. I would be lying if I said I don't ever want to money from it. Given the availability of other commercial alternatives, I don't think monetizing the product itself is a winning strategy. I do think that if the project works really well and has a strong community, I can use that community to sell things, provide monetized support, build offshoot/complementary products for money, etc.

I want to make sure I do this in an ethical and honest way. If people are volunteering their time to contribute, even if I monetize something tangential, I'm still benefiting from these people's free work indirectly. The last thing I want to do is alienate the community because of how I personally benefit from their collaboration.

-Collaboration. Now that the product is starting to get "out there" a little bit, I do have some programmers and graphic designers who are starting to contribute small pieces. Now I need to built almost a secondary project for creating tickets, documentation, etc to make it really really easy to collaborate and contribute.

Anyways, I'm extremely excited by the project because it's been something I've been messing with for last five years. This project is more or less the reason I started programming in the first place. I thought "I wanna build that..." which motivated me to learn and go back to school for a MS, get better at math, etc.

I would be deeply grateful for any advice, resources, etc from people with more experience while I navigate these early questions. My mind is racing with ideas after this soft test launch, and my motivation for this project is as high as it's ever been.

https://redd.it/1mmpi26
@r_opensource