"Represents the machine and virtual machine on which the 
 current process is executing.
 
 Holds information about runtime name, version and about 
 inherent limitations like minimum/maximum values that can 
 be represented by the runtime."​
​see (`value process`, `value language`, `value system`,
     `value operatingSystem`)
​tagged("Environment")
​shared native object runtime  {
    
    "A string that identifies the kind of virtual machine
     this process is executing:
     
     - `jvm` when executing a Java Virtual Machine,
     - `js` when executing any kind of JavaScript virtual 
       machine, or
     - `dartvm` when executing the Dart VM."​
    since ("1.3.1")
    shared native String type;
    
    "The name of the virtual machine this process is 
     executing:
     
     - `jvm` when running on a Java Virtual Machine,
     - `node.js` when running on Node.js,
     - `Browser` when running in a web browser
       (if the `window` object exists), or
     - `DartVM` when running on the Dart VM."​
    deprecated ("Use [[type]]")
    shared native String name;
    
    "The version of the virtual machine this process is 
     executing."​
    shared native String version;
    
    "The number of bits used to represent the value of an 
     [[Integer]]."​
    see (`class Integer`)
    shared native Integer integerSize;
    
    "The number of bits of [[Integer]] instances which may 
     be manipulated via the methods inherited from
     [[Binary]]."​
    since("1.1.0")
    shared native Integer integerAddressableSize;
    
    "The smallest [[Integer]] value that can be represented 
     by the runtime.
     
     It is the minimum `Integer` that can be distinguished 
     from its successor using below formula:
     
     `Integer(n-1) = Integer(n) - 1` with `Integer(0) = 0`"​
    see (`class Integer`)
    shared native Integer minIntegerValue;
​
    "The largest [[Integer]] value that can be represented 
     by the runtime.
     
     It is the maximum `Integer` that can be distinguished 
     from its predecessor using below formula:
     
     `Integer(n+1) = Integer(n) + 1` with `Integer(0) = 0`"​
    see (`class Integer`)
    shared native Integer maxIntegerValue;
    
    "The maximum size of an [[Array]] that is possible for 
     this runtime. Note that this is a theoretical limit 
     only. In practice it is usually impossible to allocate 
     an array of this size, due to memory constraints."​
    see (`class Array`)
    since("1.1.0")
    shared native Integer maxArraySize;
    
    "The largest finite [[Float]] value that can be 
     represented by the runtime."​
    since("1.2.0")
    shared native Float maxFloatValue;
​
    "The smallest positive nonzero [[Float]] value that can 
     be represented by the runtime."​
    since("1.2.0")
    shared native Float minFloatValue;
    
    "The _machine epsilon_ for [[floating point|Float]]
     values. That is, the smallest value `e` such that:
     
         1.0 + e > 1.0"​
    since("1.2.0")
    shared native Float epsilon; 
    
    "The largest [[Integer]] that can be exactly represented
     as a [[Float]] without loss of precision. The negative
     of this value is the smallest `Integer` that can be
     exactly represented as a `Float`."​
    see (`value Integer.float`)
    since("1.2.0")
    shared native Integer maxExactIntegralFloat;
    
    string => "runtime [``type`` / ``version``]";
}
​
​shared native("jvm") object runtime  {
    
    import java.lang {
        System, 
        Long, 
        Double, 
        Int=Integer, 
        Math​
    }
​
    shared native("jvm") String type => "jvm";
    shared native("jvm") String name => "jvm";
    shared native("jvm") String version 
            => System.getProperty(
                    "java.specification.version");
    
    shared native("jvm") Integer integerSize 
            => 64;
    shared native("jvm") Integer integerAddressableSize 
            => 64;
    shared native("jvm") Integer minIntegerValue 
            => Long.minValue;
    shared native("jvm") Integer maxIntegerValue 
            => Long.maxValue;
    shared native("jvm") Integer maxArraySize 
            = Int.maxValue - 8;
    shared native("jvm") Float maxFloatValue 
            => Double.maxValue;
    shared native("jvm") Float minFloatValue 
            => Double.minValue;    
    shared native("jvm") Float epsilon 
            = Math.ulp(1.0);
    shared native("jvm") Integer maxExactIntegralFloat 
            = 2^53-1;
    
}
​
​shared native("js") object runtime  {
    
    shared native("js") String type => "js";
    shared native("js") String name {
        dynamic {
            if (is String version 
                = process.propertyValue("node.version")) {
                return "node.js";
            }
            else if (exists window) {
                return "Browser";
            }
            else {
                return "Unknown JavaScript environment";
            }
        }
    }
    shared native("js") String version {
        dynamic { 
            if (is String version 
                = process.propertyValue("node.version")) {
                return version;
            }
            else if (is String version 
                = process.propertyValue("browser.version")) {
                return version;
            }
            else {
                return "Unknown";
            }
        }
    }
    
    shared native("js") Integer integerSize => 53;
    shared native("js") Integer integerAddressableSize => 32;
    shared native("js") Integer minIntegerValue = -(2^53-1);
    shared native("js") Integer maxIntegerValue = 2^53-1;
    shared native("js") Integer maxArraySize = 2^32-1;
    shared native("js") Float epsilon = 2.0^(-52);
    shared native("js") Integer maxExactIntegralFloat 
            => maxIntegerValue;
    shared native("js") Float maxFloatValue {
        dynamic {
            return \iNumber.\iMAX_VALUE;
        }
    }
    shared native("js") Float minFloatValue {
        dynamic {
            return \iNumber.\iMIN_VALUE;
        }
    }
    
}
​