Colony
#Knowledge
With Autonomi, we are finally free to host content forever, without fears of censorship or link rot. The problem is, how do you easily share that data with your friends? Or search for things that interest you? Or remember where all of your data is stored? Colony is an easy to use GUI that solves these problems to bring Autonomi to the masses.
Description
Features
Target Users
Data types
Visit my Github to read more technical info and test the demo app, currently you have to compile from source. Binary releases will be provided as soon as all baseline features are in place.
What is Colony?
Colony is a native cross-platform (Linux, Windows, Mac) desktop application written in Rust leveraging the Slint GUI framework. It enables users to upload, download, share, and search for files on the Autonomi network. There are no servers, no oracles, and no curated databases of information.
The goal of Colony is to make the Autonomi network successful. The most successful network on the internet is undoubtedly the WWW. What made the WWW successful 30 years ago was the search engine and its ubiquitous search bar. But the WWW is based on servers and clients. Servers know everything there is to know and can respond to client requests, but with Autonomi, we have no such such server, so how do we get our search bar?
How it works
Like Autonomi, Colony leverages a small set of rules and applies the concept of emergence. The concept can be described like this:
Upload files
Write metadata about files to a publically readable scratchpad called a pod in RDF
Share this pod address with your friends
Add your friends' pod addresses to your pod
With only a few addresses per user, this friend of a friend of a friend topology will build up a dynamically generated manifest of all collateral on the network, without a server or all knowing oracle. Users of Colony will automatically create a metadata layer to Autonomi, enabling client side search operations, without a middle man.
Because the user created metadata is in scratchpads:
Metadata can be appended, modified, refactored, or deleted at 0 cost once created.
The user owns the data fully and is in control. Share some pods with some users, but not others. Or don't share certain pods at all for personal data.
Data is portable to any other application using the same metadata concept. No lock in!
Like modern crypto wallets, Colony leverages a 12 word seed phrase generated master key that it uses to derive keys for all generated pod scratchpads. To recover all of your data or work with it in another application, all you need is your 12 word seed phrase.
Status of Colony
Colony has been in daily development for the last month. The demo app currently does the following:
GUI skeleton written in Slint UI
Installation GUI procedure complete
Generate a master key from an input or auto generated BIP39 compliant seed phrase
Generate configuration file
Import ETH private key and fetch Arbitrum ETH/ANT balances from the network
Encrypt all private keys within a password protected cocoon
Connects to the Autonomi network
Next steps:
Generate metadata scratchpad pods from input fields (1 week)
Upload files and metadata pods to Autonomi alpha network (2 weeks)
Download files from Autonomi using information from pods (2 weeks)
And then SEARCH!! (2 weeks)
High level: The boilerplate code and learning Rust in general is in place. Ready to start plugging in the core network features!
Bonus features to be added after the Impossible Futures challenge (or before if there is time!):
Automatic metadata populate from open data sources like OMDb, MusicBrainz, and OpenLibrary
Create API to connect a 3rd party local AI agent to handle metadata queries
Build a server mode for Colony to enable self hosting in a docker image and develop a web application for interacting with your Colony instance anywhere you have a web browser.
Build a Colony mobile client for Android and IPhone to connect to a self hosted server
Have another idea for an add-on? Let me know on discord or the Autonomi Forum!
Scaling and Thoughts on the Future
Leveraging metadata in this way is a force multiplier, but eventually Colony will run into scalability issues. A home desktop just won't have the capabilty to handle searches on massive datasets. How many files can we reasonably track? Some fuzzy math:
Assume 2KB of metadata on average per file
Scratchpads are 4MB in size, but assume 5% overhead for pod duplication, syntax, etc.
This calculates to a metadata to storage ratio of 475 files/MB. What would it take for Colony to index all of the Internet Archive's files?:
44 million books and texts
15 million audio recordings
10.6 million videos
4.8 million images
1 million software programs
Or about 75 million files in total. Based on the back of the napkin calculation above, it would take about 160GB of disk space to index the entirety of the Internet Archive's 145 PBs of file data. A hefty desktop would be required, but it wouldn't be impossible to self host.
By the time we get to a cache size of hundreds of GB on Autonomi, a distributed search mechanism will be implemented to parse the database, or better, AI agents will exist within Autonomi itself leveraging this dataset and responding to queries from users. It is a future concern, but I have no doubt a future genius will figure out a solution.
About the developer
I am a 15 year veteran of the semiconductor industry, working in design, verification, and implementation. I've published and presented 4 papers at the Design and Verification Conference (DVCon), winning the Stuart Sutherland Best Paper Presentation award in 2023 for my paper on a novel real number modelling and verification framework in SystemVerilog. I contributed to the IEEE 1800.2023 SystemVerilog standard, writing the real constraints and coverage section. I am also a lead contributor to the Accellera SystemVerilog Mixed Signal Interface committee, which is in the process of developing an automated signal type adaptation system for SystemVerilog. In 2009 before starting my career, I hiked the entirety of the 2100 mile Appalachian Trail, even after suffering a back injury that took me off the trail for 6 weeks. To put it simply, when I set my mind to doing something, I get the job done. I am a life long tinkerer, builder, and maker, living on my homestead in east Tennessee with my beautiful wife of 15 years, 3 free-range kids, and an old dog that has an uncanny ability to find skunks.
Conclusion
The end goal for Colony isn’t to be the end-all app for Autonomi. It is simply the first application using the metadata scheme above, setting up a framework and serving as a model for other apps to leverage in the future. The hope is that other Autonomi apps will leverage this framework, enabling us all to benefit from the ability to seamlessly move between apps and search for data in a common way.
For any app developers out there, if you want to leverage the same metadata and seed generation concepts in your own apps, send me a message! I'm happy to help where I can.
Please consider dropping some ANT on Colony! Thank you for your consideration!
Description
Features
Target Users
Data types
Visit my Github to read more technical info and test the demo app, currently you have to compile from source. Binary releases will be provided as soon as all baseline features are in place.
What is Colony?
Colony is a native cross-platform (Linux, Windows, Mac) desktop application written in Rust leveraging the Slint GUI framework. It enables users to upload, download, share, and search for files on the Autonomi network. There are no servers, no oracles, and no curated databases of information.
The goal of Colony is to make the Autonomi network successful. The most successful network on the internet is undoubtedly the WWW. What made the WWW successful 30 years ago was the search engine and its ubiquitous search bar. But the WWW is based on servers and clients. Servers know everything there is to know and can respond to client requests, but with Autonomi, we have no such such server, so how do we get our search bar?
How it works
Like Autonomi, Colony leverages a small set of rules and applies the concept of emergence. The concept can be described like this:
Upload files
Write metadata about files to a publically readable scratchpad called a pod in RDF
Share this pod address with your friends
Add your friends' pod addresses to your pod
With only a few addresses per user, this friend of a friend of a friend topology will build up a dynamically generated manifest of all collateral on the network, without a server or all knowing oracle. Users of Colony will automatically create a metadata layer to Autonomi, enabling client side search operations, without a middle man.
Because the user created metadata is in scratchpads:
Metadata can be appended, modified, refactored, or deleted at 0 cost once created.
The user owns the data fully and is in control. Share some pods with some users, but not others. Or don't share certain pods at all for personal data.
Data is portable to any other application using the same metadata concept. No lock in!
Like modern crypto wallets, Colony leverages a 12 word seed phrase generated master key that it uses to derive keys for all generated pod scratchpads. To recover all of your data or work with it in another application, all you need is your 12 word seed phrase.
Status of Colony
Colony has been in daily development for the last month. The demo app currently does the following:
GUI skeleton written in Slint UI
Installation GUI procedure complete
Generate a master key from an input or auto generated BIP39 compliant seed phrase
Generate configuration file
Import ETH private key and fetch Arbitrum ETH/ANT balances from the network
Encrypt all private keys within a password protected cocoon
Connects to the Autonomi network
Next steps:
Generate metadata scratchpad pods from input fields (1 week)
Upload files and metadata pods to Autonomi alpha network (2 weeks)
Download files from Autonomi using information from pods (2 weeks)
And then SEARCH!! (2 weeks)
High level: The boilerplate code and learning Rust in general is in place. Ready to start plugging in the core network features!
Bonus features to be added after the Impossible Futures challenge (or before if there is time!):
Automatic metadata populate from open data sources like OMDb, MusicBrainz, and OpenLibrary
Create API to connect a 3rd party local AI agent to handle metadata queries
Build a server mode for Colony to enable self hosting in a docker image and develop a web application for interacting with your Colony instance anywhere you have a web browser.
Build a Colony mobile client for Android and IPhone to connect to a self hosted server
Have another idea for an add-on? Let me know on discord or the Autonomi Forum!
Scaling and Thoughts on the Future
Leveraging metadata in this way is a force multiplier, but eventually Colony will run into scalability issues. A home desktop just won't have the capabilty to handle searches on massive datasets. How many files can we reasonably track? Some fuzzy math:
Assume 2KB of metadata on average per file
Scratchpads are 4MB in size, but assume 5% overhead for pod duplication, syntax, etc.
This calculates to a metadata to storage ratio of 475 files/MB. What would it take for Colony to index all of the Internet Archive's files?:
44 million books and texts
15 million audio recordings
10.6 million videos
4.8 million images
1 million software programs
Or about 75 million files in total. Based on the back of the napkin calculation above, it would take about 160GB of disk space to index the entirety of the Internet Archive's 145 PBs of file data. A hefty desktop would be required, but it wouldn't be impossible to self host.
By the time we get to a cache size of hundreds of GB on Autonomi, a distributed search mechanism will be implemented to parse the database, or better, AI agents will exist within Autonomi itself leveraging this dataset and responding to queries from users. It is a future concern, but I have no doubt a future genius will figure out a solution.
About the developer
I am a 15 year veteran of the semiconductor industry, working in design, verification, and implementation. I've published and presented 4 papers at the Design and Verification Conference (DVCon), winning the Stuart Sutherland Best Paper Presentation award in 2023 for my paper on a novel real number modelling and verification framework in SystemVerilog. I contributed to the IEEE 1800.2023 SystemVerilog standard, writing the real constraints and coverage section. I am also a lead contributor to the Accellera SystemVerilog Mixed Signal Interface committee, which is in the process of developing an automated signal type adaptation system for SystemVerilog. In 2009 before starting my career, I hiked the entirety of the 2100 mile Appalachian Trail, even after suffering a back injury that took me off the trail for 6 weeks. To put it simply, when I set my mind to doing something, I get the job done. I am a life long tinkerer, builder, and maker, living on my homestead in east Tennessee with my beautiful wife of 15 years, 3 free-range kids, and an old dog that has an uncanny ability to find skunks.
Conclusion
The end goal for Colony isn’t to be the end-all app for Autonomi. It is simply the first application using the metadata scheme above, setting up a framework and serving as a model for other apps to leverage in the future. The hope is that other Autonomi apps will leverage this framework, enabling us all to benefit from the ability to seamlessly move between apps and search for data in a common way.
For any app developers out there, if you want to leverage the same metadata and seed generation concepts in your own apps, send me a message! I'm happy to help where I can.
Please consider dropping some ANT on Colony! Thank you for your consideration!
Description
Features
Target Users
Data types
Visit my Github to read more technical info and test the demo app, currently you have to compile from source. Binary releases will be provided as soon as all baseline features are in place.
What is Colony?
Colony is a native cross-platform (Linux, Windows, Mac) desktop application written in Rust leveraging the Slint GUI framework. It enables users to upload, download, share, and search for files on the Autonomi network. There are no servers, no oracles, and no curated databases of information.
The goal of Colony is to make the Autonomi network successful. The most successful network on the internet is undoubtedly the WWW. What made the WWW successful 30 years ago was the search engine and its ubiquitous search bar. But the WWW is based on servers and clients. Servers know everything there is to know and can respond to client requests, but with Autonomi, we have no such such server, so how do we get our search bar?
How it works
Like Autonomi, Colony leverages a small set of rules and applies the concept of emergence. The concept can be described like this:
Upload files
Write metadata about files to a publically readable scratchpad called a pod in RDF
Share this pod address with your friends
Add your friends' pod addresses to your pod
With only a few addresses per user, this friend of a friend of a friend topology will build up a dynamically generated manifest of all collateral on the network, without a server or all knowing oracle. Users of Colony will automatically create a metadata layer to Autonomi, enabling client side search operations, without a middle man.
Because the user created metadata is in scratchpads:
Metadata can be appended, modified, refactored, or deleted at 0 cost once created.
The user owns the data fully and is in control. Share some pods with some users, but not others. Or don't share certain pods at all for personal data.
Data is portable to any other application using the same metadata concept. No lock in!
Like modern crypto wallets, Colony leverages a 12 word seed phrase generated master key that it uses to derive keys for all generated pod scratchpads. To recover all of your data or work with it in another application, all you need is your 12 word seed phrase.
Status of Colony
Colony has been in daily development for the last month. The demo app currently does the following:
GUI skeleton written in Slint UI
Installation GUI procedure complete
Generate a master key from an input or auto generated BIP39 compliant seed phrase
Generate configuration file
Import ETH private key and fetch Arbitrum ETH/ANT balances from the network
Encrypt all private keys within a password protected cocoon
Connects to the Autonomi network
Next steps:
Generate metadata scratchpad pods from input fields (1 week)
Upload files and metadata pods to Autonomi alpha network (2 weeks)
Download files from Autonomi using information from pods (2 weeks)
And then SEARCH!! (2 weeks)
High level: The boilerplate code and learning Rust in general is in place. Ready to start plugging in the core network features!
Bonus features to be added after the Impossible Futures challenge (or before if there is time!):
Automatic metadata populate from open data sources like OMDb, MusicBrainz, and OpenLibrary
Create API to connect a 3rd party local AI agent to handle metadata queries
Build a server mode for Colony to enable self hosting in a docker image and develop a web application for interacting with your Colony instance anywhere you have a web browser.
Build a Colony mobile client for Android and IPhone to connect to a self hosted server
Have another idea for an add-on? Let me know on discord or the Autonomi Forum!
Scaling and Thoughts on the Future
Leveraging metadata in this way is a force multiplier, but eventually Colony will run into scalability issues. A home desktop just won't have the capabilty to handle searches on massive datasets. How many files can we reasonably track? Some fuzzy math:
Assume 2KB of metadata on average per file
Scratchpads are 4MB in size, but assume 5% overhead for pod duplication, syntax, etc.
This calculates to a metadata to storage ratio of 475 files/MB. What would it take for Colony to index all of the Internet Archive's files?:
44 million books and texts
15 million audio recordings
10.6 million videos
4.8 million images
1 million software programs
Or about 75 million files in total. Based on the back of the napkin calculation above, it would take about 160GB of disk space to index the entirety of the Internet Archive's 145 PBs of file data. A hefty desktop would be required, but it wouldn't be impossible to self host.
By the time we get to a cache size of hundreds of GB on Autonomi, a distributed search mechanism will be implemented to parse the database, or better, AI agents will exist within Autonomi itself leveraging this dataset and responding to queries from users. It is a future concern, but I have no doubt a future genius will figure out a solution.
About the developer
I am a 15 year veteran of the semiconductor industry, working in design, verification, and implementation. I've published and presented 4 papers at the Design and Verification Conference (DVCon), winning the Stuart Sutherland Best Paper Presentation award in 2023 for my paper on a novel real number modelling and verification framework in SystemVerilog. I contributed to the IEEE 1800.2023 SystemVerilog standard, writing the real constraints and coverage section. I am also a lead contributor to the Accellera SystemVerilog Mixed Signal Interface committee, which is in the process of developing an automated signal type adaptation system for SystemVerilog. In 2009 before starting my career, I hiked the entirety of the 2100 mile Appalachian Trail, even after suffering a back injury that took me off the trail for 6 weeks. To put it simply, when I set my mind to doing something, I get the job done. I am a life long tinkerer, builder, and maker, living on my homestead in east Tennessee with my beautiful wife of 15 years, 3 free-range kids, and an old dog that has an uncanny ability to find skunks.
Conclusion
The end goal for Colony isn’t to be the end-all app for Autonomi. It is simply the first application using the metadata scheme above, setting up a framework and serving as a model for other apps to leverage in the future. The hope is that other Autonomi apps will leverage this framework, enabling us all to benefit from the ability to seamlessly move between apps and search for data in a common way.
For any app developers out there, if you want to leverage the same metadata and seed generation concepts in your own apps, send me a message! I'm happy to help where I can.
Please consider dropping some ANT on Colony! Thank you for your consideration!
Updates
Digging through the details
-
13/05/2025
Status
Its been a busy week, but I have some good news to share! Lets dig in:
New developer onboard!
Joining the Colony team is Maxx, a 10 year software engineer with an extensive JavaScript background. While my software development skills are akin to a toddler making macaroni art, Maxx is over here painting the Mona Lisa. His skills will be invaluable to making Colony not only functional, but a polished well tuned application
New development stack!
With 2 of us doing the work, we can divide and conquer. I spent much of the last month fighting Slint UI, drudging through type conversion hell. While it is OK, the JavaScript GUI world is leaps and bounds ahead. Based on a forum suggestion from loziniak, we dug into Tauri 2 which allows Maxx to focus on the frontend (which will be written using Svelte) and me to work solely on the Autonomi and crypto interactions in rust. Tauri 2 is fully cross platform, including for mobile, so one stack to rule them all. This is definitely the way to go.
But wait, isn't this change going to slow things down? That's what we've been working on this week!
Frontend Progress
Maxx basically rewrote the entire GUI demo that I had built in an afternoon and connected a couple buttons to some of my existing rust functions. So we're up and running! No check-ins yet (still very messy), but we're getting there.
Backend Progress
As for me, I've split out the core rust functions that I built in my demo, cleaned them up, and created a new repo on github called ColonyLib. As I've said in my pitches, I want to build up an Autonomi metadata standard. Colony is really just the vehicle to get us there. Colony will leverage ColonyLib to handle the master key creation, key derivation, pod creation, updates, and potentially RDF queries. This means any other Autonomi application can grab ColonyLib and know that whatever they write using their frontend application with be directly interoperable with Colony and its content discovery system.
Pods are being created!
Just this evening, I have successfully implemented a pointer/scratchpad combination in ColonyLib that I am calling a pod. The scratchpad is publicly readable (which is working!). The pointer points to the scratchpad and the counter field is updated for each update. The idea here is that when a user wants to refresh their pod cache (i.e. download all updates to pods) they just need to download the pointer, check if the count value is higher than their local cached copy, and then download the scratchpad vs downloading the scratchpad each time when often times, many of these will not change. The pointer can also be used to 'hide' data or move the pointer to something else. The concept here was for SOMA so that they could provide health information and when a user was done sharing that data with the provider, they could either point the pointer to itself or point it to some other data. Obviously, the provider could be caching that information, but I don't think we can solve that in an 'everything done client side' world. Another problem for another day!
Thank you for your support!
Things are moving along nicely and we're getting ready for the next phase. But we can't do it without all of you! Thank you for all your support keeping Colony in the running. I am deeply honored. It makes the late nights and little sleep all worth it.
With your help, we can get this project finished and enable the world to Search Autonomi Simply!
Digging through the details
-
13/05/2025
Status
Its been a busy week, but I have some good news to share! Lets dig in:
New developer onboard!
Joining the Colony team is Maxx, a 10 year software engineer with an extensive JavaScript background. While my software development skills are akin to a toddler making macaroni art, Maxx is over here painting the Mona Lisa. His skills will be invaluable to making Colony not only functional, but a polished well tuned application
New development stack!
With 2 of us doing the work, we can divide and conquer. I spent much of the last month fighting Slint UI, drudging through type conversion hell. While it is OK, the JavaScript GUI world is leaps and bounds ahead. Based on a forum suggestion from loziniak, we dug into Tauri 2 which allows Maxx to focus on the frontend (which will be written using Svelte) and me to work solely on the Autonomi and crypto interactions in rust. Tauri 2 is fully cross platform, including for mobile, so one stack to rule them all. This is definitely the way to go.
But wait, isn't this change going to slow things down? That's what we've been working on this week!
Frontend Progress
Maxx basically rewrote the entire GUI demo that I had built in an afternoon and connected a couple buttons to some of my existing rust functions. So we're up and running! No check-ins yet (still very messy), but we're getting there.
Backend Progress
As for me, I've split out the core rust functions that I built in my demo, cleaned them up, and created a new repo on github called ColonyLib. As I've said in my pitches, I want to build up an Autonomi metadata standard. Colony is really just the vehicle to get us there. Colony will leverage ColonyLib to handle the master key creation, key derivation, pod creation, updates, and potentially RDF queries. This means any other Autonomi application can grab ColonyLib and know that whatever they write using their frontend application with be directly interoperable with Colony and its content discovery system.
Pods are being created!
Just this evening, I have successfully implemented a pointer/scratchpad combination in ColonyLib that I am calling a pod. The scratchpad is publicly readable (which is working!). The pointer points to the scratchpad and the counter field is updated for each update. The idea here is that when a user wants to refresh their pod cache (i.e. download all updates to pods) they just need to download the pointer, check if the count value is higher than their local cached copy, and then download the scratchpad vs downloading the scratchpad each time when often times, many of these will not change. The pointer can also be used to 'hide' data or move the pointer to something else. The concept here was for SOMA so that they could provide health information and when a user was done sharing that data with the provider, they could either point the pointer to itself or point it to some other data. Obviously, the provider could be caching that information, but I don't think we can solve that in an 'everything done client side' world. Another problem for another day!
Thank you for your support!
Things are moving along nicely and we're getting ready for the next phase. But we can't do it without all of you! Thank you for all your support keeping Colony in the running. I am deeply honored. It makes the late nights and little sleep all worth it.
With your help, we can get this project finished and enable the world to Search Autonomi Simply!
Digging through the details
-
13/05/2025
Status
Its been a busy week, but I have some good news to share! Lets dig in:
New developer onboard!
Joining the Colony team is Maxx, a 10 year software engineer with an extensive JavaScript background. While my software development skills are akin to a toddler making macaroni art, Maxx is over here painting the Mona Lisa. His skills will be invaluable to making Colony not only functional, but a polished well tuned application
New development stack!
With 2 of us doing the work, we can divide and conquer. I spent much of the last month fighting Slint UI, drudging through type conversion hell. While it is OK, the JavaScript GUI world is leaps and bounds ahead. Based on a forum suggestion from loziniak, we dug into Tauri 2 which allows Maxx to focus on the frontend (which will be written using Svelte) and me to work solely on the Autonomi and crypto interactions in rust. Tauri 2 is fully cross platform, including for mobile, so one stack to rule them all. This is definitely the way to go.
But wait, isn't this change going to slow things down? That's what we've been working on this week!
Frontend Progress
Maxx basically rewrote the entire GUI demo that I had built in an afternoon and connected a couple buttons to some of my existing rust functions. So we're up and running! No check-ins yet (still very messy), but we're getting there.
Backend Progress
As for me, I've split out the core rust functions that I built in my demo, cleaned them up, and created a new repo on github called ColonyLib. As I've said in my pitches, I want to build up an Autonomi metadata standard. Colony is really just the vehicle to get us there. Colony will leverage ColonyLib to handle the master key creation, key derivation, pod creation, updates, and potentially RDF queries. This means any other Autonomi application can grab ColonyLib and know that whatever they write using their frontend application with be directly interoperable with Colony and its content discovery system.
Pods are being created!
Just this evening, I have successfully implemented a pointer/scratchpad combination in ColonyLib that I am calling a pod. The scratchpad is publicly readable (which is working!). The pointer points to the scratchpad and the counter field is updated for each update. The idea here is that when a user wants to refresh their pod cache (i.e. download all updates to pods) they just need to download the pointer, check if the count value is higher than their local cached copy, and then download the scratchpad vs downloading the scratchpad each time when often times, many of these will not change. The pointer can also be used to 'hide' data or move the pointer to something else. The concept here was for SOMA so that they could provide health information and when a user was done sharing that data with the provider, they could either point the pointer to itself or point it to some other data. Obviously, the provider could be caching that information, but I don't think we can solve that in an 'everything done client side' world. Another problem for another day!
Thank you for your support!
Things are moving along nicely and we're getting ready for the next phase. But we can't do it without all of you! Thank you for all your support keeping Colony in the running. I am deeply honored. It makes the late nights and little sleep all worth it.
With your help, we can get this project finished and enable the world to Search Autonomi Simply!
End marketing, start working!
-
08/05/2025
Status
Ending the mad dash marketing push week and starting to dig back into the code
Performing some analysis of the demo app and determining exactly what needs to be completed for MVP.
Created a a first pass functional requrements document and posted on github here: Requrements.md. These are mostly thoughts for myself, so may not make total sense, but wanted to share it anyway!
Shoutout to the community
If anyone has other critical features they think I should add to MVP, post a comment to the Colony topic on the Autonomi Forum or reach out to me on Discord in the general chat.
Thank you all who have voted for Colony so far! Let's make Autonomi great!!
End marketing, start working!
-
08/05/2025
Status
Ending the mad dash marketing push week and starting to dig back into the code
Performing some analysis of the demo app and determining exactly what needs to be completed for MVP.
Created a a first pass functional requrements document and posted on github here: Requrements.md. These are mostly thoughts for myself, so may not make total sense, but wanted to share it anyway!
Shoutout to the community
If anyone has other critical features they think I should add to MVP, post a comment to the Colony topic on the Autonomi Forum or reach out to me on Discord in the general chat.
Thank you all who have voted for Colony so far! Let's make Autonomi great!!
End marketing, start working!
-
08/05/2025
Status
Ending the mad dash marketing push week and starting to dig back into the code
Performing some analysis of the demo app and determining exactly what needs to be completed for MVP.
Created a a first pass functional requrements document and posted on github here: Requrements.md. These are mostly thoughts for myself, so may not make total sense, but wanted to share it anyway!
Shoutout to the community
If anyone has other critical features they think I should add to MVP, post a comment to the Colony topic on the Autonomi Forum or reach out to me on Discord in the general chat.
Thank you all who have voted for Colony so far! Let's make Autonomi great!!
