In the programming language of your choice, shut down the machine that your code was executed on.
This is code-golf, thus the lowest amount of bytes wins!
Removed 1 byte thanks to Snowman
#include<cstdlib> main(){system("shutdown/p");} This should shutdown the system for windows
#include<cstdlib> main(){system("poweroff");} This should shutdown the system for Linux
;? \$\endgroup\$ #include<cstdlib> will shave off a byte. \$\endgroup\$ Invoke the shell command with Run.
Run@"Shutdown/p" shutdown +0 is the traditional way to do a shutdown and power off (using the tersest representations of the flags); shutdown with no arguments will delay 60 seconds then shut down. On recent systemd-based systems you're supposed to use systemctl halt or systemctl poweroff instead, but that's more bytes so who cares about that. Note that any of these commands require root permissions (as shutting down the system could cause data loss for anyone else logged in at the time, it's an action that affects other users, so you need enough permissions to be able to do that). \$\endgroup\$ shutdown -h now alternatively : init 0
sudo \$\endgroup\$ ClrHome:" Basically, this displays a blank screen and then waits for automatic timeout to kick in and shutdown the calculator, although you will not notice when this happens. The blank screen resembles a shutdown so you will not notice when the device actually shuts down.
shell_exec("init 0"); 
shell("shutdown/s") Previous answer :
system("shutdown/s") 
WIN/P Only works from real mode (MS-DOS command prompt).
Amstrad CPC cannot be physically shut down by software, but system can be reset.
The following one-byte assembly program is enough to reset system:
C7 ;RST 0 It is a valid assembly program (in RAM) since no header of any kind is needed on this system.
You can install this program from BASIC e.g.:
poke 999,&c7 Then call it:
call 999 You can test at once on CPCBox - Amstrad CPC emulator in Javascript.
(trivial-shell:shell-command "init 0") open("/proc/sysrq-trigger","w").write("o") Can be run either from python -c or from script, and requires root privileges to write to the file. The idea isn't python-specific. Writing to that file on Linux can be done in any other way - bash, perl, ruby , etc.
Note that this isn't a graceful shutdown, so expect that there is potential for data to be lost. See the Wikipedia article for more info on sysrq keys.
open("/proc/sysrq-trigger","w").write("o") saves a few bytes. \$\endgroup\$ new ActiveXObject('WScript.Shell').Run("shutdown /s") JScript is Microsoft's implementation of JavaScript. Run with wscript scriptname.js.
import subprocess subprocess.call(["shutdown", "/s"]) This does give a window and shutdown warning. If you wanted to shut it down immediately then you would use "/p".
You could also call the function from the USER library but this is a longer solution than the submitted version.
os.system('shutdown\s') not work? I don't want to try it right now in case it does work :) \$\endgroup\$ s inside the shutdown directory. (Windows 10) \$\endgroup\$ os.system('shutdown/s') \$\endgroup\$ Amstrad CPC cannot be physically shut down by software, but system can be reset with this BASIC call:
call 0 At the beginning of memory (either RAM or ROM, both are prepared for this), there is a table for Z80 RST instruction. These instructions, related to Z80 interrupt handling, are also used (even on machines other than Amstrad CPC, like TI-81) for other tricks because one-byte long assembly instruction is enough to reach any of the 8 entries.
On the Amstrad CPC they are used to space-efficiently call code in ROM, RAM, expansion RAM/ROM, see BIOS Function Summary - CPCWiki or ref page 8+. This is used extensively to make RAM-based indirections that allow easily calling ROM routines from RAM (even from BASIC, like call &bd19 that waits for screen refresh) and also, by changing them, modifying system behavior even though system is in ROM (like changing how text is displayed, or even redirecting it to printer by changing two bytes of RAM). See BB00 and following in BIOS Function Summary - CPCWiki or Firmware Guide
Entry zero jumps to a ROM-base routine that performs full machine reset. The simplest way to call it from BASIC it call 0.
If you insist on a program that can be run rather than a direct command, it takes 8 keypresses:
1call 0 Then you can run.
You can test at once on CPCBox - Amstrad CPC emulator in Javascript.
GO64 You will then be prompted with:
ARE YOU SURE? Press Y and enter. This shuts down the C128 native mode (I know it doesn't power off the computer, but that's as close as I can get).
fa f4 Disassembly
cli ; disable all maskable interrupts hlt ; stop the processor until an interrupt or hard reset happens The HLT instruction causes the CPU to stop execution and enter low-power mode, until any interrupt (maskable or NMI) or hard reset happens. This doesn't power off the whole system, but the original IBM PC didn't have any way to power off without the user mechanically pressing the switch. Also, if there happens an NMI, and its handler returns, the program will resume and execute arbitrary code which happens after f4. This is unlikely though, since NMI usually signals about hardware faults.
This same code will work as a DOS .COM program.
`halt` Requires you to be root.
It makes use of the undocumented monad ŒV, which takes a list, concatenates it and evaluates it using Python's eval.
“WƒuUḤøMŒƁEḄV#ẆṄⱮṁƬṅȯV»ŒV The compressed string translates to import os;os.system("poweroff") so it only works on Linux (with root). The following code was used for compressing.
Compress().dictionary('import') .string(' os;os.') .dictionary('system') .string('("') .dictionary('power') .dictionary('off') .string('")').go() By changing the poweroff it can be extended to other systems (but power and off are in the dictionary so this will probably be the shortest). For example, following 33-byte version worked on a Mac.
“¡Ṁ\\meṾṭ£ȧ+⁾⁸}ḶṠȯƇọṣỴ\\Ḃ⁴8ġṢṾ»ŒV 
A$shutdown Explanation/ungolfed:
A main function $ execute system command shutdown shutdown 
tell application "System Events" to shut down 
app "Finder" to shut down. \$\endgroup\$ reset -s
In ASCII it would be 8 bytes but since UEFI uses UCS-16, every character takes up 2 bytes.
:!init 0 :!shutdown/p :!Stop-Computer Two dots : are required for the vim command, and the '!' redirects the command to the shell runing behind. You may require some extra permissions for this to work.
05 48 05 49 00 23 02 88 12 0a fc d2 01 80 43 80 09 0c 40 23 f7 e7 c0 01 00 04 02 88 02 80 Thumb function. Runs at an address that is 2 byte aligned, 4 byte unaligned, on the ARM7. The ARM9 cannot access these registers.
This version follows the spec by writing the two halfwords separately, like the code in libnds. Known to work on DeSuMME (it will log it in the console menu) and melonDS, and should work on hardware.
Assembler source:
.syntax unified .arch armv4t .thumb // Force misalignment to align PC load // Not part of function .p2align 2,0 .hword 0 // Begin code // void shutdown(void); .thumb_func .globl shutdown shutdown: // Load address of SPI register ldr r0, REG_SPICNT // Load packed SPI commands ldr r1, SPI_COMMANDS // Set SPIDATA to select PM_CONTROL_REG movs r3, #0x00 .Lloop: // Wait for REG_SPICNT & SPI_BUSY to clear ldrh r2, [r0] // Test bit 7 by shifting into carry flag lsrs r2, r2, #8 bcs .Lloop // Store the low 16 bits of the command to REG_SPICNT strh r1, [r0] // Store data to REG_SPIDATA strh r3, [r0, #2] // Shift in the next SPI command lsrs r1, r1, #16 // Set SPIDATA to PM_SYSTEM_PWR movs r3, #0x40 // Run again with the new commands // Then spin again until the SPI powers off the system. b .Lloop REG_SPICNT: // Address of ARM7 IO register .word 0x040001c0 // Two packed halfwords SPI_COMMANDS: // Start a command on the Power Management device, // read a byte to select the register // SPI_ENABLE | SPI_BAUD_1MHz | SPI_BYTE_MODE | SPI_CONTINUOUS | SPI_DEVICE_POWER .hword 0x8802 // Finish the command on the Power Management device, // read a byte to run the action. // SPI_ENABLE | SPI_BAUD_1MHz | SPI_BYTE_MODE | SPI_DEVICE_POWER .hword 0x8002 03 48 04 49 02 88 12 0a fc d2 01 60 02 49 f9 e7 c0 01 00 04 02 88 00 00 02 80 40 00 This function runs at a 4 byte aligned address on the ARM7.
This cheats 2 bytes by writing to SPICNT and SPIDATA at the same time in a full word write, something that has not yet been confirmed to work on hardware. It does not work on DeSuMME, but this might just be an emulator bug.
I am including this because it uses different code.
Assembler source:
.syntax unified .arch armv4t .thumb // Force 4 byte alignment .p2align 2,0 // Begin code .thumb_func .globl shutdown shutdown: // address of SPI register ldr r0, REG_SPICNT // Set SPI register bank ldr r1, SPI_SELECT_PM_CONTROL_REG .Lloop: // Wait for REG_SPICNT & SPI_BUSY to clear ldrh r2, [r0] // Test bit 7 by shifting into carry flag lsrs r2, #8 bcs .Lloop // Store to both SPICNT and SPIDATA str r1, [r0] // Send SPI command ldr r1, SPI_SEND_PM_SYSTEM_PWR // Loop again with the new value. b .Lloop .p2align 2,0 REG_SPICNT: .word 0x040001c0 // SPICNT = SPI_ENABLE | SPI_CONTINUOUS | SPI_BAUD_1MHz | SPI_DEVICE_POWER // SPIDATA = PM_CONTROL_REG SPI_SELECT_PM_CONTROL_REG: // Combined halfwords .hword 0x8802 .hword 0x0000 // SPICNT = SPI_ENABLE | SPI_BAUD_1MHz | SPI_DEVICE_POWER // SPIDATA = PM_SYSTEM_PWR SPI_SEND_PM_SYSTEM_PWR: // Combined halfwords .hword 0x8002 .hword 0x0040 
#!/bin/awk -f BEGIN{"poweroff"|getline} Assumes running on Linux and that AWK is located at /bin/awk and that the poweroff command is in the users path.
Since it uses the BEGIN block, no input is necessary. It simply pipes the output of the poweroff command into getline which it precedes to ignore.
Should work for Windows users provided they are in an environment similar to Cygwin.
### AWK, 39 bytes + 3 (` -f`) \$\endgroup\$ poweroff? Wouldn't init 0 or halt -p work? \$\endgroup\$ #! and the -f. If I just wanted a script I would leave out that line entirely since: awk 'BEGIN{"poweroff"|getline}' works just fine. That would save me 13 bytes or so, but I wouldn't consider it a program. Just me being pedantic I guess. :) \$\endgroup\$ awk that's not the first language which comes in mind when we think about codegolf :) \$\endgroup\$ main(){reboot(8);} This is not a proper shutdown. Usual caveats apply. On my MacBook Air, this resulted in a black screen with a spinning indicator, then a shutdown after a few seconds.
From disassembling the reboot function in libSystem:
movl $0x2000037, %eax # b8 37 00 00 02 pushq $0x08 # 6a 08 popq %r10 # 41 5a syscall # 0f 05 
Shutdown(1) 
import subprocess subprocess.call(["shutdown", "/s"]) Pretty simple code but can do some damage if you haven't saved anything.
import subprocess This imports the subprocess module that comes with Python that can be used across the script.
subprocess.call(["shutdown", "/s"]) subprocess.call runs a process as if you pressed Win + R. It requires a list of strings that will be joined with a space between them and executes it on the PC's shell.
import subprocess you could do from subprocess import* this way you don't spend as many bytes on the next line camping the subprocess module. \$\endgroup\$ system("shutdown -h now"); Make system call to shutdown in Linux to halt (-h) now.
Changing -h to -r will shutdown then reboot Linux.
An anonymous VBE immediate function that calls the declared windows function ExitWindowsEx from user32.dll.
To be clear, this requires a 32-Bit version of MS Office, not a 32-Bit version of Windows
Declare Sub ExitWindowsEx Lib"user32"(ByVal A&,ByVal B&) ExitWindowsEx 1,0 "cmd"{"shutdown /s"}ex Obviously you can not try this online.
On linux you can probably get away with "shutdown"ex if your distro offers the shutdown util.
`whatever`;Bash/Perl/PHP/Ruby/etc. stupiglots. \$\endgroup\$shatdown: past tense of the verb shutdown\$\endgroup\$