A lightweight, beginner-friendly utility and onboarding guide for developers and contributors getting started with the Technocore ecosystem.
The project helps users verify their local Python environment and provides a practical walkthrough from initial setup to creating a DID, connecting to Technocore, sending signed messages, and recording a contribution.
Status: Community tool Language: Python Target: Beginners and new Technocore contributors
Getting started with a new developer ecosystem can involve several setup steps:
- Installing the correct Python version
- Installing Git
- Creating an isolated virtual environment
- Installing required dependencies
- Verifying cryptographic dependencies
- Creating a local DID identity
- Sending signed messages
- Recording useful contributions
This project provides a simple environment checker together with a beginner-oriented setup guide.
The checker does not access wallets, seed phrases, private keys, or passwords.
- Check Python version
- Check whether the
cryptographypackage is installed - Display a simple environment readiness status
- Beginner-friendly setup documentation
- Practical Technocore onboarding workflow
- Security guidance for protecting local identity files
Before starting, install:
- Python 3.12 or newer
- Git
- PowerShell on Windows
Check Python:
python --versionCheck Git:
git --versionClone the starter repository:
git clone https://github.com/uangdrop/technocore-did-starter.gitEnter the project directory:
cd technocore-did-starterCreating a virtual environment keeps project dependencies isolated from the rest of your Python installation.
On Windows:
py -3.12 -m venv .venvActivate it:
.\.venv\Scripts\Activate.ps1If PowerShell blocks the activation script, you can temporarily allow scripts for the current PowerShell session:
Set-ExecutionPolicy -Scope Process -ExecutionPolicy BypassThen activate the environment again:
.\.venv\Scripts\Activate.ps1A successful activation looks similar to:
(.venv) PS C:\Users\YourName\technocore-did-starter>
Upgrade pip:
python -m pip install --upgrade pipInstall the project requirements:
python -m pip install -r requirements.txtIf the download fails temporarily, retry with a longer timeout:
python -m pip install --default-timeout=120 --retries=10 -r requirements.txtCheck Python:
python --versionCheck the cryptography package:
python -c "import cryptography; print(cryptography.__version__)"Check the Technocore agent:
python technocore_agent.py --versionA successful installation should report the installed versions without an error.
Copy technocore_check.py into your Technocore project directory.
Run:
python technocore_check.pyExample output:
Technocore Environment Checker
--------------------------------
Python: 3.12.10 [OK]
Cryptography: Installed [OK]
Environment is ready for Technocore development!
The checker is intentionally simple. Its purpose is to help beginners identify basic setup problems before continuing.
Once the environment is ready, initialize a local Technocore identity:
python technocore_agent.py initThe tool will ask for an identity passphrase.
Use a strong, unique passphrase that is not your:
- Exchange password
- Email password
- Wallet password
- API key
- Seed phrase
The initialization process creates an encrypted local identity file and displays your public DID.
A DID may look similar to:
did:key:z6Mk...
The DID is public information.
The generated identity file, such as:
identity.pem
must be treated as sensitive.
identity.pem- Your identity passphrase
- Seed phrases
- Private keys
- Wallet credentials
- API secrets
- Your public DID
- Public contribution URLs
- Public GitHub repositories
- Public Technocore contribution records
Keep backups of your identity file and passphrase separately.
After creating your DID, you can interact with a Technocore room using the agent.
For example:
python technocore_agent.py say lobby "Hello from a new Technocore contributor."The command will request your identity passphrase.
A successful response provides information such as:
- Room
- Sequence number
- DID
- Timestamp
- Nonce
Keep the relevant public record information for your contribution history.
A contribution should provide something useful to the ecosystem.
Examples include:
- Developer tools
- Integrations
- Examples
- Test vectors
- Focused fixes
- Tutorials
- Documentation improvements
- Research
- Educational resources
For a code contribution, this repository provides a small example:
technocore-environment-checker/
├── README.md
└── technocore_check.py
The goal is to make onboarding easier for new contributors.
After publishing your contribution, copy its public URL.
For example, a GitHub repository URL might look like:
https://github.com/your-username/your-contribution
You can record the contribution in the Technocore room:
python technocore_agent.py say technocore "I published a Technocore contribution: YOUR_PUBLIC_URL"Replace YOUR_PUBLIC_URL with the actual public URL.
The signed response provides a sequence number that can be used as part of the public contribution record.
Keep track of:
- Contribution URL
- Technocore room
- Sequence number
- Public DID
These provide a simple public trail connecting the contribution with the DID used to publish it.
Do not publish your private identity material.
This project involves cryptographic identity files.
Always follow these rules:
identity.pem
or any file containing:
private key
seed phrase
passphrase
API key
wallet credentials
Before pushing a repository to GitHub, review the files being uploaded.
A good practice is to use a .gitignore file and keep private identity files outside contribution repositories.
Run:
Set-ExecutionPolicy -Scope Process -ExecutionPolicy BypassThen:
.\.venv\Scripts\Activate.ps1This changes the execution policy only for the current PowerShell process.
Check installed Python versions:
py --listThen try:
py -3.12 --versionIf Python 3.12 is not installed, install Python 3.12 or newer.
Check:
git --versionIf Git is not installed, install Git for Windows and reopen PowerShell.
Retry:
python -m pip install --default-timeout=120 --retries=10 -r requirements.txtTemporary network failures can interrupt package downloads.
If you have already initialized a DID, make sure you are running the command from the same project directory where the identity file was created.
Check the current directory:
pwdDo not create a new identity unnecessarily if you already have an existing identity you intend to use.
A typical setup looks like:
technocore-did-starter/
├── .venv/
├── identity.pem
├── requirements.txt
└── technocore_agent.py
The separate contribution repository should contain only public project files, for example:
technocore-environment-checker/
├── README.md
└── technocore_check.py
Keep the private identity environment separate from public contribution repositories.
The purpose of this project is to reduce friction for new Technocore contributors.
Instead of troubleshooting several setup requirements independently, beginners can use the environment checker and follow the documented workflow step by step.
The project is intentionally small so that new contributors can understand the code and extend it with additional checks.
Possible improvements include:
- Check Git installation automatically
- Check the active virtual environment
- Detect the installed Technocore agent
- Add automated tests
- Add Linux and macOS instructions
- Add CI checks with GitHub Actions
- Provide more detailed diagnostic output
Contributions and improvements are welcome.
Ideas for improvements include:
- Bug fixes
- Additional environment checks
- Documentation improvements
- Tests
- Platform-specific setup instructions
- Developer experience improvements
Please keep contributions focused, documented, and safe.
MIT