Menu
Coddy logo textTech
JETZT LERNEN
flag De iconDeutschdown icon

Solidity Playground

Code-Snippets schreiben, ausführen und teilen — keine Einrichtung nötig.

Contract.sol
Klicken Sie auf Ausführen, um die Ausgabe hier zu sehen.
ArgsValues passed to your contract’s main(...) function. The runner ABI-encodes them based on the parameter types.
No arguments. Click "Add arg" to pass one.

Solidity im Browser ausprobieren

Solidity ist die Sprache der Ethereum-Smart-Contracts. Sie läuft auf der EVM — derselben virtuellen Maschine, die im Mainnet hunderte Milliarden Dollar absichert und die meisten L2s antreibt. Dieses Playground gibt dir einen Monaco-Editor, der an eine sandboxed solc + geth EVM angebunden ist, sodass du einen Vertrag schreiben, auf Run drücken und exakt sehen kannst, was on-chain passieren würde: console.log-Ausgabe, emittierte Events und der finale Zustand deiner Storage-Variablen — ohne irgendetwas zu deployen, ohne Gas zu zahlen und ohne eine Wallet anzufassen.

Solidity hat ein paar Eigenheiten, auf die man am Anfang achten sollte. Storage ist standardmäßig permanent — alles, was du einer State-Variable zuweist, bleibt erhalten; alles innerhalb einer Funktion ist weg, sobald der Aufruf zurückkehrt. Events sind die Art, wie Contracts mit der Außenwelt sprechen (dein Frontend, dein Indexer, The Graph) — sie kosten Gas, werden in die Transaction-Logs geschrieben und sind nach indexed-Parametern filterbar. Und jede externe Funktion bekommt ihre Eingaben über ABI-Encoding, nicht über stdin — deshalb hat das Playground ein typisiertes Args-Panel, das direkt an deine main(...)-Parameter angeschlossen ist.

Was dieses Solidity-Playground gut macht

  • Echte solc + EVM-Ausführung, keine Transpiler-Simulation. console.log läuft über forge-std, und die emit- / Storage-Pfade durchlaufen echte EVM-Semantik — Opcodes, Gas, alles.
  • Der Events-Tab zeigt jedes emit deines Laufs mit deutlich markierten indexed-Parametern, sodass du siehst, was ein Frontend oder ein Subgraph genau empfangen würde.
  • Der Storage-Tab zeigt den finalen Wert jeder State-Variable, die der Vertrag angefasst hat — inklusive Mapping-Einträgen (z. B. balances[0xabc...]). Variablen, die du nicht beschrieben hast, tauchen nicht auf.
  • Typisiertes Args-Panel, das Werte an ein parametrisches main(uint256 n, string memory name, ...) reicht. Der Runner ABI-encodet sie anhand der Funktionssignatur, sodass 42 zu uint256 und "hello" zu string wird.

Was du im Solidity-Playground bauen kannst

  • Counter- / Increment-Decrement-Contracts, um zu lernen, wie State-Variablen über Aufrufe hinweg bestehen — schreibe in count, führe aus und beobachte, wie es im Storage-Tab erscheint.
  • Token-Flow-Muster — emittiere Transfer(from indexed, to indexed, value) und sieh, wie indexed- und non-indexed-Felder im Events-Tab unterschiedlich gerendert werden, genauso wie sie in echten EVM-Log-Topics auftauchen.
  • require / revert-Fehlerfälle — schreibe einen Guard, der bei schlechtem Input fehlschlägt, und sieh die Revert-Meldung im stdout erscheinen, statt im Mainnet Gas an einer fehlgeschlagenen Transaktion zu verbrennen.

Häufig gestellte Fragen zu Solidity

Was ist Solidity?
Solidity ist die am weitesten verbreitete Smart-Contract-Sprache für Ethereum und EVM-kompatible Chains (Polygon, Arbitrum, Optimism, Base usw.). Sie kompiliert zu EVM-Bytecode — einem Stack-Maschinen-Instruktionssatz, den jeder Node im Netz ausführt. Syntaktisch borgt sie von JavaScript und C++, aber die Semantik ist sehr anders: Storage ist teuer und permanent, jeder Aufruf wird in Gas gemessen und es gibt kein async. Das Playground gibt dir eine sandboxed EVM, damit du die Sprache üben kannst, ohne eine echte Chain anzufassen.
Brauche ich eine Wallet oder Testnet-ETH, um das zu nutzen?
Nein. Das Playground führt deinen Vertrag in einer serverseitigen EVM (derselben Engine, die geth ausliefert) in einem isolierten Container pro Request aus. Keine On-Chain-Transaktion, kein Gas in echter ETH, keine Wallet-Signatur. Wenn du auf Run drückst, deployt der Runner deinen Vertrag auf eine frische In-Memory-Chain, ruft deine main(...)-Funktion mit den angegebenen Args auf und zeigt dir stdout, Events und Storage aus diesem einen Aufruf. Nach dem Run wird alles weggeworfen.
Wie übergebe ich Eingaben an meinen Vertrag?
Gib deinem Vertrag eine Funktion namens main(...) mit den typisierten Parametern, die du willst — function main(uint256 n) external oder function main(string memory name, uint256 age, bool active) external view. Dann trag die Werte im Args-Panel unter dem Editor ein. Der Runner schaut sich die Signatur an und ABI-encodet deine Strings in die richtigen Typen, genauso wie cast call auf der Kommandozeile. Für ein address-Argument tippe 0x...; für bool true oder false; für uint den Dezimalwert.
Was ist der Unterschied zwischen den Tabs Output, Events und Storage?
Output zeigt, was du via console.log(...) aus forge-std/console.sol in stdout geschrieben hast, plus eine etwaige Revert- / Require-Fehlermeldung. Events zeigt jedes Event, das dein Vertrag während des Laufs emittiert hat, in der Reihenfolge und mit dem Wert jedes Parameters (und einer kleinen "indexed"-Markierung bei indexed-Parametern — das sind die, die in die EVM-Log-Topics gehen und mit Tools wie The Graph filterbar sind). Storage zeigt den Nach-Lauf-Wert jeder State-Variable, die geschrieben wurde, inklusive einzelner Mapping-Einträge — Variablen, die du nicht angefasst hast, bleiben aus der Liste raus.
Warum gibt es in einigen Solidity-Tutorials kein main()?
Auf einer echten Chain haben Solidity-Contracts keinen einzelnen Einstiegspunkt — Clients rufen einfach die öffentliche Funktion auf, die sie wollen, identifiziert über ihren 4-Byte-Selector. Das Playground verwendet main() als Konvention, damit es etwas Offensichtliches zum Ausführen gibt und einen Ort für Argumente. Außerhalb des Playgrounds wird dein Vertrag typischerweise mehrere Funktionen exponieren (mint, transfer, withdraw, ...) und dein Frontend oder ein Tool wie cast / ethers / viem entscheidet, welche aufgerufen wird.