Hostname

From Rosetta Code
(Redirected from Discover the Hostname)
Task
Hostname
You are encouraged to solve this task according to the task description, using any language you may know.
Task

Find the name of the host on which the routine is running.

Ada[edit]

Works with GCC/GNAT

with Ada.Text_IO; use Ada.Text_IO;
with GNAT.Sockets;

procedure Demo is
begin
   Put_Line (GNAT.Sockets.Host_Name);
end Demo;

Aikido[edit]

println (System.hostname)

ALGOL 68[edit]

Works with: ALGOL 68G version Any - tested with release mk15-0.8b.fc9.i386
Works with: POSIX version .1
STRING hostname;
get(read OF execve child pipe("/bin/hostname","hostname",""), hostname);
print(("hostname: ", hostname, new line))

AppleScript[edit]

host name of (system info)

Arc[edit]

(system "hostname -f")

AutoHotkey[edit]

MsgBox % A_ComputerName

via Windows Management Instrumentation (WMI)

for objItem in ComObjGet("winmgmts:\\.\root\CIMV2").ExecQuery("SELECT * FROM Win32_ComputerSystem")
    MsgBox, % "Hostname:`t" objItem.Name

AWK[edit]

WARNING: the following purported solution makes an assumption about environment variables that may not be applicable in all circumstances.
$ awk 'BEGIN{print ENVIRON["HOST"]}'
E51A08ZD

BaCon[edit]

PRINT "Hostname: ", HOSTNAME$

Batch File[edit]

Since Windows 2000 :

Hostname

BBC BASIC[edit]

      INSTALL @lib$+"SOCKLIB"
      PROC_initsockets
      PRINT "hostname: " FN_gethostname
      PROC_exitsockets

C/C++[edit]

Works with: gcc version 4.0.1
Works with: POSIX version .1
#include <stdlib.h>
#include <stdio.h>
#include <limits.h>
#include <unistd.h>
 
int main(void)
{
 char name[_POSIX_HOST_NAME_MAX + 1];
 return gethostname(name, sizeof name) == -1 || printf("%s\n", name) < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
}

C#[edit]

System.Net.Dns.GetHostName();

Caché ObjectScript[edit]

Write ##class(%SYS.System).GetNodeName()

Clojure[edit]

(.. java.net.InetAddress getLocalHost getHostName)
java -cp clojure.jar clojure.main -e "(.. java.net.InetAddress getLocalHost getHostName)"

COBOL[edit]

       identification division.
       program-id. hostname.

       data division.
       working-storage section.
       01 hostname pic x(256).
       01 nullpos  pic 999 value 1.

       procedure division.
       call "gethostname" using hostname by value length of hostname
       string hostname delimited by low-value into hostname
           with pointer nullpos
       display "Host: " hostname(1 : nullpos - 1)
       goback.
       end program hostname.

CoffeeScript[edit]

os = require 'os'
console.log os.hostname()

Common Lisp[edit]

Another operating system feature that is implemented differently across lisp implementations. Here we show how to create a function that obtains the required result portably by working differently for each supported implementation. This technique is heavily used to make portable lisp libraries.

(defun get-host-name ()
    #+(or sbcl ccl) (machine-instance)
    #+clisp (let ((s (machine-instance))) (subseq s 0 (position #\Space s)))
    #-(or sbcl ccl clisp) (error "get-host-name not implemented"))
Library: CFFI

Another way is to use the FFI to access POSIX' gethostname(2):

(cffi:defcfun ("gethostname" c-gethostname) :int
  (buf :pointer) (len :unsigned-long))

(defun get-hostname ()
  (cffi:with-foreign-object (buf :char 256)
    (unless (zerop (c-gethostname buf 256))
      (error "Can't get hostname"))
    (values (cffi:foreign-string-to-lisp buf))))
BOA> (get-hostname)
"aurora"

Crystal[edit]

hostname = System.hostname

D[edit]

import std.stdio, std.socket;

void main() {
    writeln(Socket.hostName());
}

Delphi[edit]

program ShowHostName;

{$APPTYPE CONSOLE}

uses Windows;

var
  lHostName: array[0..255] of char;
  lBufferSize: DWORD;
begin
  lBufferSize := 256;
  if GetComputerName(lHostName, lBufferSize) then
    Writeln(lHostName)
  else
    Writeln('error getting host name');
end.

E[edit]

makeCommand("hostname")()[0].trim()

Not exactly a good way to do it. A better way ought to be introduced along with a proper socket interface.

Emacs Lisp[edit]

(system-name)

Erlang[edit]

Host = net_adm:localhost().

F#[edit]

printfn "%s" (System.Net.Dns.GetHostName())

Factor[edit]

USE: io.sockets
host-name

Forth[edit]

Works with: GNU Forth version 0.7.0
include unix/socket.fs

hostname type

Fortran[edit]

Works with: gfortran

The function/subroutine HOSTNM is a GNU extension.

program HostTest
  character(len=128) :: name 
  call hostnm(name)
  print *, name
end program HostTest

Using fortran 2003 C-interoperability we can call posix C function gethostname (unix system call) directly

program test_hostname
   use, intrinsic  :: iso_c_binding
   implicit none
   interface !to function: int gethostname(char *name, size_t namelen);
      integer(c_int) function gethostname(name, namelen) bind(c)
         use, intrinsic  :: iso_c_binding, only: c_char, c_int, c_size_t
         integer(c_size_t), value, intent(in) :: namelen
         character(len=1,kind=c_char), dimension(namelen),  intent(inout) ::  name
      end function gethostname
   end interface
   integer(c_int) :: status
   integer,parameter :: HOST_NAME_MAX=255
   character(kind=c_char,len=1),dimension(HOST_NAME_MAX) :: cstr_hostname
   integer(c_size_t) :: lenstr
   character(len=:),allocatable :: hostname
   lenstr = HOST_NAME_MAX
   status = gethostname(cstr_hostname, lenstr)
   hostname = c_to_f_string(cstr_hostname)
   write(*,*) hostname, len(hostname)

 contains
   ! convert c_string to f_string
   pure function c_to_f_string(c_string) result(f_string)
      use, intrinsic :: iso_c_binding, only: c_char, c_null_char
      character(kind=c_char,len=1), intent(in) :: c_string(:)
      character(len=:), allocatable :: f_string
      integer i, n
      i = 1
      do
         if (c_string(i) == c_null_char) exit
         i = i + 1
      end do
      n = i - 1  ! exclude c_null_char
      allocate(character(len=n) :: f_string)
      f_string = transfer(c_string(1:n), f_string)
   end function c_to_f_string

end program test_hostname

FreeBASIC[edit]

' FB 1.05.0 Win64

' On Windows 10, the command line utility HOSTNAME.EXE prints the 'hostname' to the console.
' We can execute this remotely and read from its 'stdin' stream as follows:

Dim As String hostname
Open Pipe "hostname" For Input As #1
Input #1, hostname
Close #1
Print hostname
Print
Print "Press any key to quit"
Sleep

friendly interactive shell[edit]

Translation of: UNIX Shell
hostname

or

uname -n

Frink[edit]

callJava["java.net.InetAddress", "getLocalHost"].getHostName[]


FutureBasic[edit]

include "NSLog.incl"
NSLog( @"%@", fn ProcessInfoHostName )
HandleEvents


Gambas[edit]

Click this link to run this code

Public Sub Main()

Print System.Host

End

Output:

charlie

Go[edit]

Use os.Hostname.

package main

import (
	"fmt"
	"os"
)

func main() {
	fmt.Println(os.Hostname())
}

Groovy[edit]

println InetAddress.localHost.hostName

Harbour[edit]

? NetName()

Haskell[edit]

Library: network
import Network.BSD
main = do hostName <- getHostName
          putStrLn hostName

Or if you don't want to depend on the network package being installed, you can implement it on your own (this implementation is based on the implementation in the network package).


module GetHostName where

import Foreign.Marshal.Array ( allocaArray0, peekArray0 )
import Foreign.C.Types ( CInt(..), CSize(..) )
import Foreign.C.String ( CString, peekCString )
import Foreign.C.Error ( throwErrnoIfMinus1_ )

getHostName :: IO String
getHostName = do
  let size = 256
  allocaArray0 size $ \ cstr -> do
    throwErrnoIfMinus1_ "getHostName" $ c_gethostname cstr (fromIntegral size)
    peekCString cstr

foreign import ccall "gethostname" 
   c_gethostname :: CString -> CSize -> IO CInt

main = do hostName <- getHostName
          putStrLn hostName

Icon and Unicon[edit]

procedure main()
  write(&host)
end

IDL[edit]

hostname = GETENV('computername')

J[edit]

NB. Load the socket libraries

  load 'socket'
  coinsert 'jsocket'

NB. fetch and implicitly display the hostname

  > {: sdgethostname ''

NB. If fetching the hostname is the only reason for loading the socket libraries,
NB. and the hostname is fetched only once, then use a 'one-liner' to accomplish it:

  > {: sdgethostname coinsert 'jsocket' [ load 'socket'

Java[edit]

import java.net.*;
class DiscoverHostName {
 public static void main(final String[] args) {
  try {
   System.out.println(InetAddress.getLocalHost().getHostName());
  } catch (UnknownHostException e) { // Doesn't actually happen, but Java requires it be handled.
  }
 }
}

JavaScript[edit]

Works with: JScript
var network = new ActiveXObject('WScript.Network');
var hostname = network.computerName;
WScript.echo(hostname);

jq[edit]

Currently jq does not have a "gethostname" or a "system" command, so the best ways for a jq program to have access to the hostname are via an environment variable, or via a command line argument, as illustrated here:

HOST=$(hostname) jq -n --arg hostname $(hostname) '[env.HOST, $hostname]'
Output:
[
  "mini.local",
  "mini.local"
]

Jsish[edit]

var hn = exec("hostname", {retAll:true}).data.trim();

Julia[edit]

println(gethostname())
Output:
harlan

K[edit]

_h
Output:
`"narasimman-pc"

Kotlin[edit]

// version 1.1.4

import java.net.InetAddress

fun main(args: Array<String>) {
    println(InetAddress.getLocalHost().hostName)
}

Lasso[edit]

This will ge the hostname as reported by the web server

[web_request->httpHost]

-> www.myserver.com

This will ge the hostname as reported by the system OS

define host_name => thread {

	data
		public initiated::date, // when the thread was initiated. Most likely at Lasso server startup
		private hostname::string // as reported by the servers hostname

	public onCreate() => {
		.reset
	}

	public reset() => {
		if(lasso_version(-lassoplatform) >> 'Win') => {
			protect => {
				local(process = sys_process('cmd',(:'hostname.exe')))
				#process -> wait
				.hostname = string(#process -> readstring) -> trim&
				#process -> close
			}
		else
			protect => {
				local(process = sys_process('/bin/hostname'))
				#process -> wait
				.hostname = string(#process -> readstring) -> trim&
				#process -> close
			}
		}
		.initiated = date(date -> format(`yyyyMMddHHmmss`)) // need to set format to get rid of nasty hidden fractions of seconds
		.hostname -> size == 0 ? .hostname = 'undefined'
	}

	public asString() => .hostname

}

host_name

-> mymachine.local

LFE[edit]

(net_adm:localhost)

Liberty BASIC[edit]

lpBuffer$=Space$(128) + Chr$(0)
struct SIZE,sz As Long
SIZE.sz.struct=Len(lpBuffer$)

calldll #kernel32, "GetComputerNameA",lpBuffer$ as ptr, SIZE as struct, result as Long
CurrentComputerName$=Trim$(Left$(lpBuffer$, SIZE.sz.struct))

print CurrentComputerName$

Limbo[edit]

As with nearly anything in Inferno, it boils down to reading a file:

implement Hostname;

include "sys.m"; sys: Sys;
include "draw.m";

Hostname: module {
	init: fn(nil: ref Draw->Context, nil: list of string);
};

init(nil: ref Draw->Context, nil: list of string)
{
	sys = load Sys Sys->PATH;
	buf := array[Sys->ATOMICIO] of byte;

	fd := sys->open("/dev/sysname", Sys->OREAD);
	if(fd == nil)
		die("Couldn't open /dev/sysname");

	n := sys->read(fd, buf, len buf - 1);
	if(n < 1)
		die("Couldn't read /dev/sysname");

	buf[n++] = byte '\n';
	sys->write(sys->fildes(1), buf, n);
}

die(s: string)
{
	sys->fprint(sys->fildes(2), "hostname: %s: %r", s);
	raise "fail:errors";
}

Sys->ATOMICIO is usually 8 kilobytes; this version truncates if you have a ridiculously long hostname.

Lingo[edit]

Library: Shell Xtra
sx = xtra("Shell").new()
if the platform contains "win" then
  hostname = sx.shell_cmd("hostname", ["eol":RETURN]).line[1] -- win 7 or later
else
  hostname = sx.shell_cmd("hostname", RETURN).line[1]
end if

LiveCode[edit]

answer the hostName

Lua[edit]

Requires: LuaSocket

socket = require "socket"
print( socket.dns.gethostname() )

M2000 Interpreter[edit]

Module Host {
      \\ one way
      Print computer$
      \\ second way
      Declare objNetwork "WScript.Network"
      With objNetwork,  "ComputerName" as cName$
      Print cName$, cName$=Computer$
      Declare objNetwork Nothing
}
Host

Maple[edit]

Sockets:-GetHostName()

Mathematica / Wolfram Language[edit]

$MachineName

MATLAB[edit]

This is a built-in MATLAB function. "failed" is a Boolean which will be false if the command sent to the OS succeeds. "hostname" is a string containing the system's hostname, provided that the external command hostname exists.

[failed,hostname] = system('hostname')

mIRC Scripting Language[edit]

echo -ag $host

Modula-3[edit]

MODULE Hostname EXPORTS Main;

IMPORT IO, OSConfig;

BEGIN
  IO.Put(OSConfig.HostName() & "\n");
END Hostname.

MUMPS[edit]

Write $Piece($System,":")

NetRexx[edit]

/* NetRexx */
options replace format comments java crossref savelog symbols binary

say InetAddress.getLocalHost.getHostName

NewLISP[edit]

(! "hostname")

Nim[edit]

There are several ways to get the host name, for instance reading the environment variable HOSTNAME or calling the low level Posix function “gethostname”. The simplest way consists to use the function “getHostName” from module “nativeSockets”:

import nativesockets
echo getHostName()

Oberon-2[edit]

Works with oo2c version 2

MODULE HostName;
IMPORT 
  OS:ProcessParameters,
  Out;
BEGIN
  Out.Object("Host: " + ProcessParameters.GetEnv("HOSTNAME"));Out.Ln
END HostName.

Output:

Host: localhost.localdomain

Objeck[edit]

use Net;

bundle Default {
  class Hello {
    function : Main(args : String[]) ~ Nil {
      TCPSocket->HostName()->PrintLine();
    }
  }
}

Objective-C[edit]

Cocoa / Cocoa Touch / GNUstep:

NSLog(@"%@", [[NSProcessInfo processInfo] hostName]);

Example Output:

2010-09-16 16:20:00.000 Playground[1319:a0f] sierra117.local // Hostname is sierra117.local.

OCaml[edit]

Unix.gethostname()

Octave[edit]

Similarly to MATLAB, we could call system command hostname to know the hostname. But we can also call the internal function uname() which returns a structure holding several informations, among these the hostname (nodename):

uname().nodename

ooRexx[edit]

These solutions are platform specific.

Windows Platform[edit]

A solution using ActiveX/OLE on Windows

say .oleObject~new('WScript.Network')~computerName

and one using the Windows environment variables

say value('COMPUTERNAME',,'environment')

UNIX Platform[edit]

Some UNIX solutions (tested under Mac OS X):

ooRexx (and Rexx) can issue commands directly to the shell it's running under. Output of the shell commands will normally be STDOUT and STDERR. These next two samples will simply output the host name to the console if the program is run from a command prompt.

Note: The address command clause causes the contents of the literal string that follows it to be sent to the command shell.
address command 'hostname -f'
address command "echo $HOSTNAME"

Command output can also be captured by the program to allow further processing. ooRexx provides an external data queue manager (rxqueue) that can be used for this. In the following examples output written to STDOUT/STDERR is piped into rxqueue which sends it in turn to a Rexx queue for further processing by the program:

/* Rexx */
address command "echo $HOSTNAME | rxqueue"
address command "hostname -f | rxqueue"
loop q_ = 1 while queued() > 0
  parse pull hn
  say q_~right(2)':' hn
  end q_

A utility class is also provided as a wrapper around the external data queue:

/* Rexx */
qq = .rexxqueue~new()
address command "echo $HOSTNAME | rxqueue"
address command "hostname -f | rxqueue"
loop q_ = 1 while qq~queued() > 0
  hn = qq~pull()
  say q_~right(2)':' hn
  end q_

Oz[edit]

{System.showInfo {OS.getHostByName 'localhost'}.name}

PARI/GP[edit]

Running the hostname or uname program and capturing its output (the first line of output) in a string.

str = externstr("hostname")[1];
str = externstr("uname -n")[1];

Pascal[edit]

For Windows systems see the Delphi example. On Unix systems, FreePascal has the function GetHostName:

Program HostName;

uses
  unix;

begin
  writeln('The name of this computer is: ', GetHostName);
end.

Output example on Mac OS X:

The name of this computer is: MyComputer.local

Perl[edit]

Works with: Perl version 5.8.6
use Sys::Hostname;

$name = hostname;

Phix[edit]

without js -- (system_exec, file i/o)
constant tmp = "hostname.txt",
         cmd = iff(platform()=WINDOWS?"hostname":"uname -n")
{} = system_exec(sprintf("%s > %s",{cmd,tmp}),4)
string host = trim(get_text(tmp))
{} = delete_file("hostname.txt")
?host
Output:
"Pete-PC"

PHP[edit]

echo $_SERVER['HTTP_HOST'];
echo php_uname('n');
Works with: PHP version 5.3+
echo gethostname();

PicoLisp[edit]

This will just print the hostname:

(call 'hostname)

To use it as a string in a program:

(in '(hostname) (line T))

Pike[edit]

import System;

int main(){
   write(gethostname() + "\n");
}

PL/SQL[edit]

SET serveroutput on
BEGIN
  DBMS_OUTPUT.PUT_LINE(UTL_INADDR.GET_HOST_NAME);  
END;

Pop11[edit]

lvars host = sys_host_name();

PowerBASIC[edit]

This retreives the localhost's name:

HOST NAME TO hostname$

This attempts to retreive the name of an arbitrary machine on the network (assuming ipAddress& is valid):

HOST NAME ipAddress& TO hostname$

PowerShell[edit]

Windows systems have the ComputerName environment variable which can be used:

$Env:COMPUTERNAME

Also PowerShell can use .NET classes and methods:

[Net.Dns]::GetHostName()

PureBasic[edit]

Works with: PureBasic version 4.41
InitNetwork()
answer$=Hostname()

Python[edit]

Works with: Python version 2.5
import socket
host = socket.gethostname()

R[edit]

Sys.info provides information about the platform that R is running on. The following code returns the hostname as a string.

Sys.info()[["nodename"]]

Note that Sys.info isn't guaranteed to be available on all platforms. As an alternative, you can call an OS command.

system("hostname", intern = TRUE)

... or retrieve an environment variable

env_var <- ifelse(.Platform$OS.type == "windows", "COMPUTERNAME", "HOSTNAME") 
Sys.getenv(env_var)

Racket[edit]

#lang racket/base
(require racket/os)
(gethostname)

Raku[edit]

(formerly Perl 6)

my $host = qx[hostname];

REBOL[edit]

print system/network/host

REXX[edit]

REGINA and PC/REXX under most MS NT Windows[edit]

This REXX solution is for REGINA and PC/REXX under the Microsoft NT family of Windows (XP, Vista, 7, etc).
Other names could be used for the 3rd argument.

The   computername   is the same as the output for the   hostname.exe   program.

say value('COMPUTERNAME',,"ENVIRONMENT")
say value('OS',,"ENVIRONMENT")

output (using Windows/XP)

GERARD46
Windows_NT

R4 and ROO under most MS NT Windows[edit]

This REXX solution is for R4 and ROO under the Microsoft NT family of Windows (XP, Vista, 7, etc).
Other names could be used for the 3rd argument.

say value('COMPUTERNAME',,"SYSTEM")
say value('OS',,"SYSTEM")

MS DOS (without Windows), userid[edit]

Under Microsoft DOS (with no Windows), the closest thing to a name of a host would be the userid.

say userid()

MS DOS (without Windows), version of DOS[edit]

But perhaps the name or version of the MS DOS system would be more appropriate than the userid.

'VER'    /*this passes the  VER  command to the MS DOS system. */

Each REXX interpreter has their own name (some have multiple names) for the environmental variables.
Different operating systems may call their hostnames by different identifiers.
IBM mainframes (at one time) called the name of the host as a nodename and it needn't be
specified, in which case an asterisk (*) is returned.
I recall (perhaps wrongly) that Windows/95 and Windows/98 had a different environmental name for the name of the host.

UNIX Solution[edit]

This solution is platform specific and uses features that are available to the Regina implementation of Rexx.

Tested with Regina on Mac OS X. Should work on other UNIX/Linux distros.
/* Rexx */
address command "hostname -f" with output stem hn.
do q_ = 1 to hn.0
  say hn.q_
  end q_
exit

Ruby[edit]

require 'socket'
host = Socket.gethostname

Run BASIC[edit]

print Platform$    ' OS where Run BASIC is being hosted
print UserInfo$    ' Information about the user's web browser
print UserAddress$ ' IP address of the user

Rust[edit]

Works on windows and linux with crate hostname version 0.1.5

fn main() {
    match hostname::get_hostname() {
        Some(host) => println!("hostname: {}", host),
        None => eprintln!("Could not get hostname!"),
    }
}

Scala[edit]

println(java.net.InetAddress.getLocalHost.getHostName)

Scheme[edit]

Works with: Chicken Scheme
(use posix)
(get-host-name)
Works with: Guile
(gethostname)

Seed7[edit]

The library socket.s7i defines the function getHostname, which returns the hostname.

$ include "seed7_05.s7i";
  include "socket.s7i";

const proc: main is func
  begin
    writeln(getHostname);
  end func;

Sidef[edit]

var sys = frequire('Sys::Hostname');
var host = sys.hostname;

Or:

var host = `hostname`.chomp;

Slate[edit]

Platform current nodeName

Slope[edit]

(hostname)

Smalltalk[edit]

Works with: Smalltalk/X
OperatingSystem getHostName

SNOBOL4[edit]

      output = host(4,"HOSTNAME")
end

SQL[edit]

Works with: Oracle
select host_name from v$instance;

SQL PL[edit]

Works with: Db2 LUW
SELECT HOST_NAME FROM SYSIBMADM.ENV_SYS_INFO

Output:

HOST_NAME                                                                                                                                                                                                                                                      
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
hostname                                                                                                                                                                                                                                                          

  1 record(s) selected.

Standard ML[edit]

NetHostDB.getHostName ()

Swift[edit]

Swift 3

print(ProcessInfo.processInfo.hostName)

Tcl[edit]

The basic introspection tool in TCL is the info command. It can be used to find out about the version of the current Tcl or Tk, the available commands and libraries, variables, functions, the level of recursive interpreter invocation, and, amongst a myriad other things, the name of the current machine:

set hname [info hostname]

Toka[edit]

2 import gethostname
1024 chars is-array foo
foo 1024 gethostname
foo type

TUSCRIPT[edit]

$$ MODE TUSCRIPT
host=HOST ()

UNIX Shell[edit]

hostname

or

uname -n

Ursa[edit]

out (ursa.net.localhost.name) endl console

Ursala[edit]

The user-defined hostname function ignores its argument and returns a string.

#import cli

hostname = ~&hmh+ (ask bash)/<>+ <'hostname'>!

For example, the following function returns the square root of its argument if it's running on host kremvax, but otherwise returns the square.

#import flo

creative_accounting = (hostname== 'kremvax')?(sqrt,sqr)

VBScript[edit]

Set objNetwork = CreateObject("WScript.Network")
WScript.Echo objNetwork.ComputerName

Vim Script[edit]

echo hostname()

Visual Basic[edit]

Works with: Visual Basic version 5
Works with: Visual Basic version 6
Works with: VBA version Access 97
Works with: VBA version 6.5
Works with: VBA version 7.1
Option Explicit

Private Declare Function GetComputerName Lib "kernel32.dll" Alias "GetComputerNameW" _
  (ByVal lpBuffer As Long, ByRef nSize As Long) As Long
 
Private Const MAX_COMPUTERNAME_LENGTH As Long = 31
Private Const NO_ERR As Long = 0

Private Function Hostname() As String
Dim i As Long, l As Long, s As String
  s = Space$(MAX_COMPUTERNAME_LENGTH)
  l = Len(s) + 1
  i = GetComputerName(StrPtr(s), l)
  Debug.Assert i <> 0
  Debug.Assert l <> 0
  Hostname = Left$(s, l)
End Function

Sub Main()
  Debug.Assert Hostname() = Environ$("COMPUTERNAME")
End Sub

V (Vlang)[edit]

In Vlang, the "main()" entry point and declaration can be skipped in one file programs and when used like a script.

import os

println(os.hostname())

Wren[edit]

Wren CLI doesn't currently expose a way to find the host name.

However, if Wren is embedded in (say) a suitable Go program, then we can ask the latter to get it for us.

/* hostname.wren */
class Host {
    foreign static name() // the code for this is provided by Go
}

System.print(Host.name())

which we embed in the following Go program and run it.

Library: WrenGo
/* hostname.go */
package main

import (
    wren "github.com/crazyinfin8/WrenGo"
    "os"
)

type any = interface{}

func hostname(vm *wren.VM, parameters []any) (any, error) {
    name, _ := os.Hostname()
    return name, nil
}

func main() {
    vm := wren.NewVM()
    fileName := "hostname.wren"
    methodMap := wren.MethodMap{"static name()": hostname}
    classMap := wren.ClassMap{"Host": wren.NewClass(nil, nil, methodMap)}
    module := wren.NewModule(classMap)
    vm.SetModule(fileName, module)
    vm.InterpretFile(fileName)
    vm.Free()
}

zkl[edit]

System.hostname

Or open a server socket, which contains the hostname.

Network.TCPServerSocket.open(8080).hostname