% update README.md

Author: EdmondDantes

README.md

@@ -11,6 +11,7 @@ tightly integrated at the core level.
 - [Installation](#installation)
     - [Unix / macOS](#unix--macos)
     - [Windows](#windows)
+- [Adapted PHP Functions](#adapted-php-functions)
 - [Quick Start](#quick-start)
 - [Documentation](#documentation)
 - [Contributing](#contributing)
@@ -105,14 +106,191 @@ Please see the [LibUV installation guide](https://github.com/libuv/libuv)
    nmake
    ```
 
+---
+
+## Adapted PHP Functions
+
+**50+ PHP functions** have been adapted to work asynchronously when used within coroutines:
+
+### DNS Functions
+- `gethostbyname()` - resolve hostname to IP address
+- `gethostbyaddr()` - resolve IP address to hostname  
+- `gethostbynamel()` - get list of IP addresses for hostname
+
+### CURL Functions  
+- `curl_exec()` - execute cURL request
+- `curl_multi_exec()` - execute multiple cURL handles
+- `curl_multi_select()` - wait for activity on multiple cURL handles
+- `curl_multi_getcontent()` - get content from multi handle
+- `curl_setopt()`, `curl_getinfo()`, `curl_error()`, `curl_close()` - async-aware
+
+### Socket Functions
+- `socket_connect()`, `socket_accept()` - connection operations
+- `socket_read()`, `socket_write()` - data transfer
+- `socket_send()`, `socket_recv()` - data exchange
+- `socket_sendto()`, `socket_recvfrom()` - addressed data transfer
+- `socket_bind()`, `socket_listen()` - server operations
+- `socket_select()` - monitor socket activity
+
+### Stream Functions
+- `file_get_contents()` - get file/URL contents
+- `fread()`, `fwrite()` - file I/O operations
+- `fopen()`, `fclose()` - file handle management
+- `stream_socket_client()`, `stream_socket_server()` - socket streams
+- `stream_socket_accept()` - accept stream connections
+- `stream_select()` - monitor stream activity
+- `stream_context_create()` - async-aware context creation
+
+### Process Execution Functions
+- `proc_open()` - open process with pipes
+- `exec()` - execute external command
+- `shell_exec()` - execute shell command
+- `system()` - execute system command  
+- `passthru()` - execute and pass output directly
+
+### Sleep/Timer Functions
+- `sleep()` - delay execution (seconds)
+- `usleep()` - delay execution (microseconds)
+- `time_nanosleep()` - nanosecond precision delay
+- `time_sleep_until()` - sleep until timestamp
+
+### Output Buffer Functions
+- `ob_start()` - start output buffering with coroutine isolation
+- `ob_flush()`, `ob_clean()` - buffer operations with isolation
+- `ob_get_contents()`, `ob_end_clean()` - get/end buffer with isolation
+
+All functions automatically become non-blocking when used in async context, allowing other coroutines to continue execution while waiting for I/O operations to complete.
+
+---
+
 ## Quick Start
 
+### Basic Coroutine Example
+
+```php
+<?php
+
+// Spawn multiple concurrent coroutines
+Async\spawn(function() {
+    echo "Starting coroutine 1\n";
+    sleep(2); // Non-blocking in async context
+    echo "Coroutine 1 completed\n";
+});
+
+Async\spawn(function() {
+    echo "Starting coroutine 2\n";
+    sleep(1); // Non-blocking in async context
+    echo "Coroutine 2 completed\n";
+});
+
+echo "All coroutines started\n";
+```
+
+### Concurrent DNS Lookups
+
+```php
+<?php
+
+$start = microtime(true);
+
+// Start multiple DNS lookups concurrently
+Async\spawn(function() {
+    $ip = gethostbyname('github.com'); // Non-blocking
+    $ips = gethostbynamel('github.com'); // Get all IPs
+    echo "GitHub: $ip (" . count($ips) . " total IPs)\n";
+});
+
+Async\spawn(function() {
+    $ip = gethostbyname('google.com'); // Non-blocking
+    $hostname = gethostbyaddr($ip); // Reverse lookup
+    echo "Google: $ip -> $hostname\n";
+});
+
+Async\spawn(function() {
+    $content = file_get_contents('http://httpbin.org/ip'); // Non-blocking
+    echo "External IP: " . json_decode($content)->origin . "\n";
+});
+
+$elapsed = microtime(true) - $start;
+echo "All operations completed in: " . round($elapsed, 3) . "s\n";
+```
+
+### Concurrent HTTP Requests with CURL
+
 ```php
 <?php
 
+$urls = [
+    'https://httpbin.org/delay/1',
+    'https://httpbin.org/delay/2',
+    'https://httpbin.org/delay/1'
+];
+
+$start = microtime(true);
+
+foreach ($urls as $i => $url) {
+    Async\spawn(function() use ($url, $i) {
+        $ch = curl_init($url);
+        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
+        curl_setopt($ch, CURLOPT_TIMEOUT, 10);
+        
+        $response = curl_exec($ch); // Non-blocking
+        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
+        curl_close($ch);
+        
+        echo "Request $i: HTTP $httpCode\n";
+    });
+}
+
+$elapsed = microtime(true) - $start;
+echo "All requests completed in: " . round($elapsed, 3) . "s\n";
+```
+
+### Process Execution
+
+```php
+<?php
+
+// Execute multiple commands concurrently
 Async\spawn(function() {
-    // Your async code here
+    $output = shell_exec('sleep 2 && echo "Command 1 done"'); // Non-blocking
+    echo $output;
 });
+
+Async\spawn(function() {
+    $output = shell_exec('sleep 1 && echo "Command 2 done"'); // Non-blocking
+    echo $output;
+});
+
+echo "Commands started\n";
+```
+
+### Output Buffering with Coroutine Isolation
+
+```php
+<?php
+
+// Each coroutine has isolated output buffer
+Async\spawn(function() {
+    ob_start(); // Isolated buffer
+    echo "Output from coroutine 1\n";
+    echo "More output from coroutine 1\n";
+    $buffer1 = ob_get_contents();
+    ob_end_clean();
+    
+    echo "Coroutine 1 captured: $buffer1";
+});
+
+Async\spawn(function() {
+    ob_start(); // Separate isolated buffer
+    echo "Output from coroutine 2\n";
+    $buffer2 = ob_get_contents();
+    ob_end_clean();
+    
+    echo "Coroutine 2 captured: $buffer2";
+});
+
+echo "Buffers are isolated between coroutines\n";
 ```
 
 ---