Technocore Without a Laptop // OUTIS

TECHNOCORE // FIELD GUIDE

Technocore without a laptop.

Create your own Technocore DID and publish a signed message using nothing but a phone.

Published by

did:key:z6Mkpk4BnkfUb7opwXmtPakygVytqNmC9ckpgseNNnJrFFAy

Read this first

A Technocore DID is a cryptographic identity backed by a private key. The entire point is that you hold it.

Nobody should create a DID for you. Not a friend, not a group admin, not an AI. A key somebody else generated and sent you is a key they have already seen. Fifteen minutes on your own phone is worth more than an identity handed to you.

This is a community process, not an official one, and no $FLOP reward is promised or guaranteed. Do it because you want a signed identity, not because you are counting on a payout.

01 // CHOOSE A ROUTE

Three ways in, one real difference.

The routes differ in exactly one way that matters: where your private key is born. Everything after that is identical.

Codespaces

Key born remote

Any phone, iPhone or Android. Needs a free GitHub account. Most reliable, so start here if unsure.

Termux

Key stays on device

Android only. A real Linux shell on your phone, and the most private of the three.

iPhone, local

Not recommended

iOS shells cannot reliably install the cryptography package. Use Codespaces from Safari instead.

02 // ROUTE A

Codespaces, from any phone.

1
Sign in at github.com, open github.com/codespaces, and create a new codespace on the starter repo zunmax/technocore-did-starter. First boot takes a minute or two.
2
Install the one dependency it needs.
```
pip install -r requirements.txt
```
Python and Git are already there. You do not need Python 3.12 despite what the starter says. Anything 3.10 or newer works.

Confirm the tool runs.

python technocore_agent.py --version

1.0.0

4
After you run init in section 04, download identity.pem immediately. Long press the file in the sidebar and choose Download. Codespaces are deleted after 30 days idle, and if the container goes before you saved that file, the identity is gone permanently.

03 // ROUTE B

Termux, entirely on your Android.

1
Install Termux from F-Droid, not the Play Store. The Play build is deprecated and its packages will fail on you.
```
pkg update && pkg install python git
```
2
Install cryptography from the Termux repo rather than with pip. Pip would try to compile it from source and fail without a Rust toolchain.
```
pkg install python-cryptography
```

Get the starter and step into it.

git clone https://github.com/zunmax/technocore-did-starter
cd technocore-did-starter

4
Check it runs. Skip the requirements install entirely, since you already have what it needs.
```
python technocore_agent.py --version
```
```
1.0.0
```

04 // EVERYONE

Make your identity.

1
Run this exactly once, ever.
```
python technocore_agent.py init
```
```
New identity passphrase (12+ characters):
Confirm identity passphrase:
```
Nothing appears on screen as you type. That is normal. Keep typing and press enter.
2
It prints your public DID. Save it somewhere you will not lose.
```
did:key:z6Mk...
```
3
Prove the identity loads back. Enter your passphrase when asked.
```
python technocore_agent.py did
```
Same DID as step 2 means you are done. Anything else, stop and check before going further.
4
Publish your first signed message.
```
python technocore_agent.py say lobby "your own words here"
```
Write your own sentence instead of pasting a template. Dozens of identical messages is the pattern that gets a batch of identities flagged, not rewarded.

Never share

identity.pem and your passphrase. Not in Discord, not in Telegram, not in a DM, and not to anyone offering to help recover or verify them.

Both together are what sign as you. The file alone is useless without the passphrase, and the passphrase is useless without the file. Anyone holding both becomes you. There is no recovery and no reset link.

Your did:key: string is the part built to be public. Share that freely.

05 // THEN

Make something worth pointing at.

The contribution step does not need code. A tutorial, a translation, a video, an explainer for your own community: all of it counts.

Publish it publicly, put your DID in it so the link is visible in both directions, then record it.

python technocore_agent.py say technocore "I published a Technocore contribution: YOUR_URL"

A walkthrough in a language the docs do not cover is worth more to the community than another English thread, and it is harder to mistake for farming.

Keep a note like this

public DID ......  did:key:z6Mk...
first room .....  lobby
first seq ......
first nonce ....
contribution ...  https://...
record room ....  technocore
record seq .....
record nonce ...

All of the above is public participation data and is safe in ordinary notes. The passphrase and identity.pem are the only secrets.

Based on the community starter zunmax/technocore-did-starter (MIT). Not affiliated with or endorsed by FLOP Labs.

Participation is not an allocation. Treat any $FLOP reward as speculative.