Terminal control/Clear the screen

Task

Clear the terminal window.

11l

Translation of: Python

To clear the screen on Windows, replace 'clear' with 'cls'

os:(‘clear’)

6502 Assembly

Commodore 64

Works with: [VICE]

This example has been written for the C64 and uses the CHROUT KERNEL routine. Compile with the Turbo Macro Pro cross assembler:

tmpx -i clrscr.s -o bin/clrscr.prg

Run with:

SYS680

; C64 - Terminal control: Clear the screen

; *** labels ***

chrout          = $ffd2

; *** main ***

                *=$02a8         ; sys 680
                
                lda clr         ; A = {CLR}
                jsr chrout      ; Output a character in A to the current
                                ; output device (default: screen).
                rts    
                
; *** data ***

clr             .byte $93       ; the CLR control code
                                ; see https://en.wikipedia.org/wiki/PETSCII

6502js/6502asm/easy6502

Works with: [6502asm.com] version 1.2

Works with: [6502asm.com] version 1.5 beta

The 6502asm.com emulator has a 32x32 pixel screen. First we fill this screen with random colored pixels, wait for a keypress and then "clear" the screen (fill it with black pixels).

; 6502asm.com - Clear the screen

                lda #$00        ; store the start address of the screen ($200)
                sta $00         ; at $00 and $01 (high byte in $01)
                lda #$02
                sta $01
                
                ldy #$00        ; Y = 0
fillscreen:                
                lda $fe         ; A = random number from $fe
                sta ($00),y     ; put pixel (random color) to the screen
                iny             ; Y++
                bne fillscreen  ; loop if Y!=0
                inc $01         ; increase address high byte
                lda $01
                cmp #$06        ; A==6? (screen ends at $05ff)
                bne fillscreen  ; no -> loop
                
waitforkeypress:                
                lda $ff         ; $ff is 0 if no key has been pressed
                beq waitforkeypress
                
                ldx #$00
                lda #$00        ; black
clearscreen:
                sta $0200,x
                sta $0300,x
                sta $0400,x
                sta $0500,x
                inx
                bne clearscreen

Nintendo Entertainment System

It's best to do this during forced blank (i.e. display is inactive), as this loop is most likely too slow to finish before vBlank is over. This code assumes that your game's character ROM has a "blank" tile at tile index $00. If it doesn't, use whatever index you consider to be a "blank tile." Also, this only clears the top-left nametable, which is all the user can see if no scrolling has taken place. If the scroll position of the screen isn't (0,0), there will still be graphics left over on screen.

clearVRAM:
PHA
LDA #$20   ;load the vram address of the top-left nametable
STA $2006
LDA #$00
STA $2006
PLA
LDX #$04    ;we've got $400 bytes to clear.
LDY #$00
loop:
STA $2007   ;write the tile, vram auto-incs.
DEY
BNE loop
DEX
BNE loop
RTS

68000 Assembly

Neo Geo MVS

The following will clear all hardware sprites from video memory as well as the "FIX Layer" (a simple tilemap intended for text). Since all of the NEO GEO's graphics are either FIX layer tiles or hardware sprites, this will clear the screen in its entirety. The only thing left will be the background color.

The registers D0, D1, and A0 will be clobbered after returning, so keep that in mind.

JSR $C004C2    ;clear the FIX layer
JSR $C004C8    ;clear hardware sprites

Sega Genesis

The fastest way to do this is with direct memory access. It is assumed that your tile pattern definition has 32 null bytes starting at VRAM offset $0000. (You need to have 32 null bytes in VRAM somewhere for this to work, it doesn't have to be at VRAM address $0000, but this example uses that for convenience.) The code below also assumes the Genesis's VDP (video display processor) has been set up as follows:

VDP register 2 = %00110000 = foreground tilemap at VRAM address $C000
VDP register 3 = %00111100 = window tilemap at VRAM address $F000
VDP register 4 = %00000111 = background tilemap at VRAM address $E000
VDP register 5 = %01101100 = sprite attribute table at VRAM address $D800

This technique uses DMA fill mode to fill the tilemaps (not the pattern definitions) with transparent tiles. This has the effect of wiping the screen of all graphics, while not disturbing the tile definitions themselves.

dma_fill:
	;input:
	;D2.L = what address to write to.
	;D1.W = DMA LENGTH (measured in words)
	;D0 = WHAT DATA TO USE TO FILL VRAM

        vdp_data equ $C00000
        vdp_ctrl equ $C00004

        MOVE.L #$40000003,D2                            ;VDP sees this as VRAM address $C000
        MOVE.W #$2000,D1                                ;fill $2000 words ($4000 bytes)
        MOVEQ #0,D0                                     ;with zeroes.
	MOVE SR,-(SP)
	MOVEM.L D3-D7,-(SP)
	
		MOVE #$2700,SR                          ;disable interrupts
		MOVEQ.L #-109,D3 			;quickly move #$FFFFFF93 into D3
		LSL.W #8,D3
		OR.B D1,D3					
		;d3 contains $93xx where xx is the low byte of dma length
		;this is the correct command to give the vdp
		
		
		LSR.W #8,D1	;shift high byte of dma length down to low byte
		
		MOVEQ.L #-108,D4			;quickly move #$FFFFFF94 into d4
		LSL.W #8,D4					;D4 = #$FFFF9400
		OR.B D1,D4
		;d3 contains $94xx where xx is the high byte of dma length
		;this is the correct command to give the vdp
		
		OR.L #$20,D2		;tells the vdp the next write is a DMA write
		
.wait:
;waiting until vblank is optional, however DMA is much faster if performed during vblank so might as well.

		move.w VDP_ctrl,d7
		and.w #%0000000000001000,d7		;See if vblank is running
		bne .wait				;wait until it is
		
		MOVE.W #($8100|%01110100),(VDP_CTRL)	;ENABLE DMA
		move.w #$8F01,(vdp_ctrl)				;set auto-inc to 1
		MOVE.W #$9780,(vdp_ctrl)				;enable dma vram fill
		MOVE.W D3,(vdp_ctrl)					;set dma length low byte
		MOVE.W D4,(vdp_ctrl)					;set dma length high byte
		MOVE.L D2,(vdp_ctrl)					;set destination address
		
		MOVE.W D0,(vdp_data)					
                ;at this point the 68000 halts until DMA is finished.


		move.w #($8100|%01100100),(VDP_CTRL)	;DISABLE DMA
		move.w #$8F02,(vdp_ctrl)		;set auto-inc back to 2
	MOVEM.L (SP)+,D3-D7
	RTR

8080 Assembly

On almost all video terminals, from the earliest ones to today's terminal emulators, sending an ASCII Form Feed control character (code 12) will clear the screen.

This program uses a CP/M system call to send a Form Feed character to the standard output, as CP/M was the de facto standard operating system for 8080-based systems.

putch:	equ	2	; CP/M 'putchar' syscall
bdos:	equ	5	; CP/M BDOS entry point
FF:	equ	12	; ASCII form feed
	org	100h
	mvi	c,putch	; Print character (syscall goes in C register)
	mvi	e,FF	; Form feed (argument goes in E register)
	jmp	bdos	; Call CP/M BDOS and quit

AArch64 Assembly

Works with: as version Raspberry Pi 3B version Buster 64 bits

/* ARM assembly AARCH64 Raspberry PI 3B */
/*  program clearScreen.s   */
 
/*******************************************/
/* Constantes file                         */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
 
.equ BUFFERSIZE,          100
/*******************************************/
/* Initialized data                        */
/*******************************************/
.data
szMessStartPgm:            .asciz "Program start \n"
szMessEndPgm:              .asciz "Program normal end.\n"
szClear:                   .asciz "\33[2J"     // console clear (id language C)
szClear1:                  .byte 0x1B 
                           .byte 'c'           // other console clear
                           .byte 0
szCarriageReturn:          .asciz "\n"
/*******************************************/ 
/* UnInitialized data                      */
/*******************************************/
.bss 
/*******************************************/
/*  code section                           */
/*******************************************/
.text
.global main 
main: 
 
    ldr x0,qAdrszMessStartPgm                   // display start message
    bl affichageMess
    //ldr x0,qAdrszClear                        // clear screen
    ldr x0,qAdrszClear1                         // change for other clear screen
    bl affichageMess
    ldr x0,qAdrszMessEndPgm                     // display end message
    bl affichageMess
 
100:                                            // standard end of the program
    mov x0,0                                    // return code
    mov x8,EXIT                                 // request to exit program
    svc 0                                       // perform system call
qAdrszMessStartPgm:       .quad szMessStartPgm
qAdrszMessEndPgm:         .quad szMessEndPgm
qAdrszClear:              .quad szClear
qAdrszClear1:             .quad szClear1
qAdrszCarriageReturn:     .quad szCarriageReturn
/********************************************************/
/*        File Include fonctions                        */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"

Action!

proc Main()
  Put(125)
return

Ada

For systems with ANSI terminal handling:

with Ada.Text_IO;
procedure CLS is
begin
   Ada.Text_IO.Put(ASCII.ESC & "[2J");
end CLS;

ALGOL 68

Works with: ALGOL 68G version Any - tested with release 2.8.3.win32

Uses the Algol 68G interface to the curses library.

curses start; # needed before any screen clearing, positioning etc. #
curses clear  # clear the screen #

ARM Assembly

Works with: as version Raspberry Pi

/* ARM assembly Raspberry PI  */
/*  program clearScreen.s   */

/* Constantes    */
.equ STDOUT, 1                           @ Linux output console
.equ EXIT,   1                           @ Linux syscall
.equ WRITE,  4                           @ Linux syscall

.equ BUFFERSIZE,          100

/* Initialized data */
.data
szMessStartPgm:            .asciz "Program start \n"
szMessEndPgm:              .asciz "Program normal end.\n"
szClear:                   .asciz "\33[2J"     @ console clear (id language C)
szClear1:                  .byte 0x1B 
                           .byte 'c'           @ other console clear
                           .byte 0
szCarriageReturn:          .asciz "\n"

/* UnInitialized data */
.bss 

/*  code section */
.text
.global main 
main: 

    ldr r0,iAdrszMessStartPgm                   @ display start message
    bl affichageMess
    //ldr r0,iAdrszClear                        @ clear screen
    ldr r0,iAdrszClear1                         @ change for other clear screen
    bl affichageMess
    ldr r0,iAdrszMessEndPgm                     @ display end message
    bl affichageMess

100:                                            @ standard end of the program
    mov r0, #0                                  @ return code
    mov r7, #EXIT                               @ request to exit program
    svc 0                                       @ perform system call
iAdrszMessStartPgm:       .int szMessStartPgm
iAdrszMessEndPgm:         .int szMessEndPgm
iAdrszClear:              .int szClear
iAdrszClear1:             .int szClear1
iAdrszCarriageReturn:     .int szCarriageReturn

/******************************************************************/
/*     display text with size calculation                         */ 
/******************************************************************/
/* r0 contains the address of the message */
affichageMess:
    push {r0,r1,r2,r7,lr}                       @ save  registers 
    mov r2,#0                                   @ counter length */
1:                                              @ loop length calculation
    ldrb r1,[r0,r2]                             @ read octet start position + index 
    cmp r1,#0                                   @ if 0 its over
    addne r2,r2,#1                              @ else add 1 in the length
    bne 1b                                      @ and loop 
                                                @ so here r2 contains the length of the message 
    mov r1,r0                                   @ address message in r1 
    mov r0,#STDOUT                              @ code to write to the standard output Linux
    mov r7, #WRITE                              @ code call system "write" 
    svc #0                                      @ call system
    pop {r0,r1,r2,r7,lr}                        @ restaur registers
    bx lr                                       @ return

Arturo

clear

AutoHotkey

Reference: http://www.autohotkey.com/forum/topic76532.html

RunWait %comspec% /c cls

AWK

system("clear")

Axe

ClrHome

BaCon

CLEAR

BASIC

Works with: QBasic

Works with: Locomotive Basic

Works with: ZX Spectrum Basic

Works with: BBC BASIC

CLS

Applesoft BASIC

HOME

Aquarius BASIC

PRINT CHR$(11);

Atari BASIC

PRINT CHR$(125);

BASIC256

      cls
#Borra la ventana de texto

y

      clg
#Borra la ventana de gráficos

BBC BASIC

CLS

or

      VDU 12

or

      PRINT CHR$(12);

Commodore BASIC

PRINT CHR$(147);

Works with: Commodore BASIC version 3.5,7.0

(Also works on a VIC-20 with the SuperExpander cartridge)

SCNCLR

GW-BASIC

10 CLS

IS-BASIC

100 CLEAR SCREEN

PureBasic

Clears the whole console content using the current background color.

ClearConsole()

True BASIC

CLEAR
END

Batch File

CLS

beeswax

Using the ANSI escape sequence Esc[2J.

_3F..}`[2J`

Befunge

Assuming a terminal with support for ANSI escape sequences.

"J2["39*,,,,@

Blast

clear

Blue

Linux/x86

global _start

: syscall ( num:eax -- result:eax ) syscall ;

: exit ( status:edi -- noret ) 60 syscall ;
: bye ( -- noret ) 0 exit ;

1 const stdout

: write ( buf:esi len:edx fd:edi -- ) 1 syscall drop ;
: print ( buf len -- ) stdout write ;

: clear-screen ( -- ) s" \033[2J\033[H" print ;

: _start ( -- noret ) clear-screen bye ;

Bracmat

sys$cls&

C / C++

The C version of the Minesweeper game uses curses.

If perhaps clear screen isn't used, call the function cls to do the trick.

void cls(void) {
    printf("\33[2J");
}

Here is the cheaty way no one likes, only works on Windows.

#include <stdio.h>
#include <stdlib.h>

void main() {
    printf ("clearing screen");
    getchar();
    system("cls");
}

For Unix-likes, changing the above system("cls"); to system("clear"); usually works, however the getchar(); perhaps doesn't always work as expected if you press anything other than return. This is because of the raw vs. cooked terminal mode thing.

C#

System.Console.Clear();

Works on all .NET Core platforms. Throws an exception if output has been redirected to a file.

COBOL

       PROGRAM-ID. blank-terminal.
       
       DATA DIVISION.
       SCREEN SECTION.
       01  blank-screen BLANK SCREEN.
       
       PROCEDURE DIVISION.
           DISPLAY blank-screen

           GOBACK
           .

Comal

PAGE

Common Lisp

(format t "~C[2J" #\Esc)

or it could be done passing the 'clear' command to the shell

(defun sh (cmd)
   "A multi-implementation function equivalent for the C function system"
   #+clisp (shell cmd)
   #+ecl (si:system cmd)
   #+sbcl (sb-ext:run-program "/bin/sh" (list "-c" cmd) :input nil :output *standard-output*)
   #+clozure (ccl:run-program "/bin/sh" (list "-c" cmd) :input nil :output *standard-output*))
(sh "clear")

ncurses

When the ncurses terminal library is used, characters are displayed on an alternate screen. Clearing that alternate screen does not clear the main screen of the terminal from which ncurses was started. To interface ncurses from Lisp, the croatoan library is used.

(defun clear-test ()
  ;; starting ncurses enters the alternate screen buffer of the terminal
  (with-screen (scr :input-echoing nil :input-blocking t)
    (princ "Text to be cleared" scr)
    (refresh scr)
    ;; wait for a keypress
    (get-char scr)
    (clear scr)
    (refresh scr)
    (get-char scr)))
;; leaving ncurses returns the terminal to the main screen buffer

D

extern (C) nothrow {
    void disp_open();
    void disp_move(int, int);
    void disp_eeop();
    void disp_close();
}

void main() {
    disp_open();
    disp_move(0, 0);
    disp_eeop();
    disp_close();
}

Dc

Using external "clear" binary

Dc's command to execute shell commands can only be the last command of a line. That's no problem with multi line Dc programs but not very helpful in Dc oneliners:

!clear

Luckily there is a loophole:

[ !clear ] x

Using a terminal control sequence

A common way to clear the screen with a terminal (assuming XTerm here) control sequence could be to home the cursor ("ESC[H", "1B 5B 48") and then clear to the end of the screen ("ESC[J", "1B 5B 4A").

16i 1B5B481B5B4A P

Delphi

Library: System.SysUtils

Library: Winapi.Windows

Stand alone function

Copy of David Heffrnan on stackoverflow [1].

uses
  System.SysUtils,
  Winapi.Windows;

procedure ClearScreen;
var
  stdout: THandle;
  csbi: TConsoleScreenBufferInfo;
  ConsoleSize: DWORD;
  NumWritten: DWORD;
  Origin: TCoord;
begin
  stdout := GetStdHandle(STD_OUTPUT_HANDLE);
  Win32Check(stdout<>INVALID_HANDLE_VALUE);
  Win32Check(GetConsoleScreenBufferInfo(stdout, csbi));
  ConsoleSize := csbi.dwSize.X * csbi.dwSize.Y;
  Origin.X := 0;
  Origin.Y := 0;
  Win32Check(FillConsoleOutputCharacter(stdout, ' ', ConsoleSize, Origin, 
    NumWritten));
  Win32Check(FillConsoleOutputAttribute(stdout, csbi.wAttributes, ConsoleSize, Origin, 
    NumWritten));
  Win32Check(SetConsoleCursorPosition(stdout, Origin));
end;

Library System.Console from Jens Borrisholt

Library: System.Console

The System.Console can be found here[2]

console.Clear;

Elena

ELENA 3.4 :

public program()
{
   console.clear()
}

Erlang

clear()->io:format(os:cmd("clear")).

Euphoria

clear_screen()

F#

open System

Console.Clear()

Forth

page

Fortran

Fortran 2008:

program clear
    character(len=:), allocatable :: clear_command
    clear_command = "clear" !"cls" on Windows, "clear" on Linux and alike
    call execute_command_line(clear_command)
end program

Intel Fortran on Windows

Using console functions, one can also clear the screen without using a system command. See also Clearing the Screen on MSDN.

program clear
    use kernel32
    implicit none
    integer(HANDLE) :: hStdout
    hStdout = GetStdHandle(STD_OUTPUT_HANDLE)
    call clear_console(hStdout)
contains
    subroutine clear_console(hConsole)
        integer(HANDLE) :: hConsole
        type(T_COORD) :: coordScreen = T_COORD(0, 0)
        integer(DWORD) :: cCharsWritten
        type(T_CONSOLE_SCREEN_BUFFER_INFO) :: csbi
        integer(DWORD) :: dwConSize
        
        if (GetConsoleScreenBufferInfo(hConsole, csbi) == 0) return
        dwConSize = csbi%dwSize%X * csbi%dwSize%Y
        
        if (FillConsoleOutputCharacter(hConsole, SCHAR_" ", dwConSize, &
            coordScreen, loc(cCharsWritten)) == 0) return

        if (GetConsoleScreenBufferInfo(hConsole, csbi) == 0) return
        
        if (FillConsoleOutputAttribute(hConsole, csbi%wAttributes, &
            dwConSize, coordScreen, loc(cCharsWritten)) == 0) return
            
        if (SetConsoleCursorPosition(hConsole, coordScreen) == 0) return
    end subroutine
end program

GNU Fortran on Windows

The preceding program can be compiled with GNU Fortran, with the following interface module for Windows API.

module kernel32
    use iso_c_binding
    implicit none
    integer, parameter :: HANDLE = C_INTPTR_T
    integer, parameter :: PVOID = C_INTPTR_T
    integer, parameter :: LPDWORD = C_INTPTR_T
    integer, parameter :: BOOL = C_INT
    integer, parameter :: SHORT = C_INT16_T
    integer, parameter :: WORD = C_INT16_T
    integer, parameter :: DWORD = C_INT32_T
    integer, parameter :: SCHAR = C_CHAR
    integer(DWORD), parameter :: STD_INPUT_HANDLE = -10
    integer(DWORD), parameter :: STD_OUTPUT_HANDLE = -11
    integer(DWORD), parameter :: STD_ERROR_HANDLE = -12

    type, bind(C) :: T_COORD
        integer(SHORT) :: X, Y
    end type
    
    type, bind(C) :: T_SMALL_RECT
        integer(SHORT) :: Left
        integer(SHORT) :: Top
        integer(SHORT) :: Right
        integer(SHORT) :: Bottom
    end type

    type, bind(C) :: T_CONSOLE_SCREEN_BUFFER_INFO
        type(T_COORD) :: dwSize
        type(T_COORD) :: dwCursorPosition
        integer(WORD) :: wAttributes
        type(T_SMALL_RECT) :: srWindow
        type(T_COORD) :: dwMaximumWindowSize
    end type

    interface
        function FillConsoleOutputCharacter(hConsoleOutput, cCharacter, &
                nLength, dwWriteCoord, lpNumberOfCharsWritten) &
                bind(C, name="FillConsoleOutputCharacterA")
            import BOOL, C_CHAR, SCHAR, HANDLE, DWORD, T_COORD, LPDWORD
            !GCC$ ATTRIBUTES STDCALL :: FillConsoleOutputCharacter
            integer(BOOL) :: FillConsoleOutputCharacter
            integer(HANDLE), value :: hConsoleOutput
            character(kind=SCHAR), value :: cCharacter
            integer(DWORD), value :: nLength
            type(T_COORD), value :: dwWriteCoord
            integer(LPDWORD), value :: lpNumberOfCharsWritten
        end function
    end interface

    interface
        function FillConsoleOutputAttribute(hConsoleOutput, wAttribute, &
                nLength, dwWriteCoord, lpNumberOfAttrsWritten) &
                bind(C, name="FillConsoleOutputAttribute")
            import BOOL, HANDLE, WORD, DWORD, T_COORD, LPDWORD
            !GCC$ ATTRIBUTES STDCALL :: FillConsoleOutputAttribute
            integer(BOOL) :: FillConsoleOutputAttribute
            integer(HANDLE), value :: hConsoleOutput
            integer(WORD), value :: wAttribute
            integer(DWORD), value :: nLength
            type(T_COORD), value :: dwWriteCoord
            integer(LPDWORD), value :: lpNumberOfAttrsWritten
        end function
    end interface
    
    interface
        function GetConsoleScreenBufferInfo(hConsoleOutput, &
                lpConsoleScreenBufferInfo) &
                bind(C, name="GetConsoleScreenBufferInfo")
            import BOOL, HANDLE, T_CONSOLE_SCREEN_BUFFER_INFO
            !GCC$ ATTRIBUTES STDCALL :: GetConsoleScreenBufferInfo
            integer(BOOL) :: GetConsoleScreenBufferInfo
            integer(HANDLE), value :: hConsoleOutput
            type(T_CONSOLE_SCREEN_BUFFER_INFO) :: lpConsoleScreenBufferInfo
        end function
    end interface
    
    interface
        function SetConsoleCursorPosition(hConsoleOutput, dwCursorPosition) &
                bind(C, name="SetConsoleCursorPosition")
            import BOOL, HANDLE, T_COORD
            !GCC$ ATTRIBUTES STDCALL :: SetConsoleCursorPosition
            integer(BOOL) :: SetConsoleCursorPosition
            integer(HANDLE), value :: hConsoleOutput
            type(T_COORD), value :: dwCursorPosition
        end function
    end interface
    
    interface
        function GetStdHandle(nStdHandle) bind(C, name="GetStdHandle")
            import HANDLE, DWORD
            !GCC$ ATTRIBUTES STDCALL :: GetStdHandle
            integer(HANDLE) :: GetStdHandle
            integer(DWORD), value :: nStdHandle
        end function
    end interface
end module

FreeBASIC

' FB 1.05.0 Win64

' FreeBASIC has a built in Cls command which clears the console on Windows
' but it may still be possible to scroll the console to view its
' previous contents. The following command prevents this.

Shell("Cls")
Sleep

Furor

cls

Yet another solution:

."\z"

FutureBasic

cls

Peri

###sysinclude system.uh
cls

Yet another solution:

."\z"

Go

External command

Probably most reliable way to clear the screen.

package main

import (
    "os"
    "os/exec"
)

func main() {
    c := exec.Command("clear")
    c.Stdout = os.Stdout
    c.Run()
}

ANSI escape code

Simplest, if your terminal supports the ANSI code you want.

package main

import "fmt"

func main() {
    fmt.Print("\033[2J")
}

Ncurses

More complex, but works across multiple terminal types.

Library: curses

package main

import (
    "log"
    "time"

    "code.google.com/p/goncurses"
)

func main() {
    s, err := goncurses.Init()
    if err != nil {
        log.Fatal("goncurses:", err)
    }
    defer goncurses.End()
    s.Println("Clearing screen...")
    s.Refresh()
    time.Sleep(1 * time.Second)

    s.Clear() // clear screen

    // Goncurses saves the screen on Init and restores it on End.  This
    // GetChar() allows you to see the effect of the program before it exits.
    s.GetChar() // press any key to continue
}

GUISS

This will only work if the terminal is sitting at a prompt.

Window:Terminal,Type:clear[enter]

Haskell

import System.Console.ANSI

main = clearScreen

Icon and Unicon

Example works for both Icon and Unicon. Determine which system command to call by querying &features at run time. Alternately, the related preprocessor symbols can be used to select the operating system.

procedure main ()
  if &features == "MS Windows" then system("cls")  # Windows
  else if &features == "UNIX" then system("clear") # Unix
end

J

Note: this is specific the java+gdi based J ide.

smwrite_jijs_ ''

Java

Using the ANSI escape sequence:

public class Clear
{
    public static void main (String[] args)
    {
        System.out.print("\033[2J");
    }
}

An alternative sequence:

public class Clear
{
    public static void main (String[] args)
    {
        System.out.print("\033\143");
    }
}

jq

"\u001B[2J"

Example:

$ jq -nr '"\u001B[2J"'

Jsish

Using ANSI terminal control codes.

/* Terminal Control, clear the screen, in Jsish */
function cls() { printf('\u001b[2J'); }

;cls();

/*
=!EXPECTSTART!=
cls() ==> ^[[2Jundefined
=!EXPECTEND!=
*/

Output:

prompt$ jsish -u terminalControlClear.jsi
[PASS] terminalControlClear.jsi

Julia

println("\33[2J")

Kotlin

Works with: Ubuntu version 14.04

// version 1.1.2

fun main(args: Array<String>) {
    println("\u001Bc")  // Esc + c
}

Lang

# \E is an escape sequence for the ESC ascii code
fn.println(\E[2J)

Lasso

local(
	esc = decode_base64('Gw==')
)

stdout(#esc + '[2J')

Logo

cleartext

There is a separate command to reset the turtle graphics window.

clearscreen
cs      ; abbreviation for clearscreen
clean   ; like cs, but doesn't reset turtle position

Lua

Unix, Linux

os.execute( "clear" )

Windows

os.execute( "cls" )

M2000 Interpreter

We can clear the screen with Form, Cls, Window statements. Each one perform something on the console form except clear it. Form change the size of letters using the size of window. Window change all. Cls change the background color, or use the same (is optional) and optional can set the line for the split screen (from that line we have scrolling). Also we can use Linespace statement (in twips) to set the line space. Statement Form set linespace automatic to give space between lines to full use of the window.

Module Checkit {
      Pen 14 ' yellow
      \\ using form we set characters by rows
      \\ this clear the screen
      Form 80, 40
      \\ magenta for background, all form for vertical scrolling
      Cls 5, 0
      Print "wait... half second"
      Wait 500
      \\ clear using background color
      Cls 
      \\ set the background (using html number for color), and set 4th line as top
      \\ for scrolling
      Cls #11bb22, 3
      Print "This is in 4th line"
      Wait  1000
      \\ now we center the form, using 12000 twips by 8000twips as border
      \\ form inside maybe smaller
      \\ font size is 16pt of current font
      Font "Courier New"
      Window 16, 12000, 8000;
      Print "This is first line"
      Wait 1000
      Font "Arial"
      \\ set the console form to screen 0, maximized
      Window 16, 0
      Cls 5   ' magenta
      Back {
            Cls 15 ' white border      
      }
}
checkit

Mathematica /Wolfram Language

Delegating to clear on terminal enabled OS(Mac Os, Linux)

Run["clear"];

min

clear

Nanoquery

cls

Nemerle

Exactly as C#. Because of possible (probable) ambiguity, this is one time it may be prudent to use:

Console.Clear();

rather than importing the Console class with using System.Console; and calling as:

Clear();

NewLISP

(! "clear")

In the newLISP command shell, this syntax is also proper:

!clear

Nim

import terminal

eraseScreen() #puts cursor at down
setCursorPos(0, 0)

NS-HUBASIC

10 CLS

Nu

Works with: Nushell version 0.96.1

clear -a

OCaml

Using the library ANSITerminal:

#load "unix.cma"
#directory "+ANSITerminal"
#load "ANSITerminal.cma"
open ANSITerminal

let () =
  erase Screen

Octave

 system clear;

 system('clear');

Pascal

clrscr;

page(output); { UCSD Pascal }

PascalABC.NET

##
Console.Clear;

Perl

Assuming some ANSI terminal, easiest way is call your system's clear command:

system('clear')

If it's needed often:

$clear = `clear`; # clear simply prints some escape sequence, cache it
#... later:
print $clear;

We can also obtain the sequence using the Term::Cap module:

use Term::Cap;

$terminal = Term::Cap->Tgetent();
$clear = $terminal->Tputs('cl');
print $clear;

#on Windows using Powershell or WT.exe
system('cls');

Phix

clear_screen()

PicoLisp

(call 'clear)

Pike

int main() {
	Process.system("clear");
	return 0;
}

Use "cls" instead of "clear" for Windows

PowerShell

Clear-Host

ProDOS

clearscurrentscreentext

Python

Works with: Python version 2.6

Works with: Ubuntu version 10.10

To clear the screen on Windows, replace 'clear' with 'cls'

import os
os.system("clear")

Or similar to C example (won't work in Winsows console, since it does not recognize ANSI sequences):

print "\33[2J"

On Windows, using functions from the kernel32 DLL:

from ctypes import *

STD_OUTPUT_HANDLE = -11

class COORD(Structure):
    pass
    
COORD._fields_ = [("X", c_short), ("Y", c_short)]
    
class SMALL_RECT(Structure):
    pass
    
SMALL_RECT._fields_ = [("Left", c_short), ("Top", c_short), ("Right", c_short), ("Bottom", c_short)]

class CONSOLE_SCREEN_BUFFER_INFO(Structure):
    pass

CONSOLE_SCREEN_BUFFER_INFO._fields_ = [
    ("dwSize", COORD),
    ("dwCursorPosition", COORD),
    ("wAttributes", c_ushort),
    ("srWindow", SMALL_RECT),
    ("dwMaximumWindowSize", COORD)
]

def clear_console():
    h = windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)

    csbi = CONSOLE_SCREEN_BUFFER_INFO()
    windll.kernel32.GetConsoleScreenBufferInfo(h, pointer(csbi))
    dwConSize = csbi.dwSize.X * csbi.dwSize.Y

    scr = COORD(0, 0)
    windll.kernel32.FillConsoleOutputCharacterA(h, c_char(b" "), dwConSize, scr, pointer(c_ulong()))
    windll.kernel32.FillConsoleOutputAttribute(h, csbi.wAttributes, dwConSize, scr, pointer(c_ulong()))
    windll.kernel32.SetConsoleCursorPosition(h, scr)

clear_console()

Quackery

Translation of: Python

On some platforms the screen will not be cleared until the output buffer is flushed e.g. by a cr/lf.

  [ $ &print("\33[2J",end='')& python ] is clearscreen

R

cat("\33[2J")

Or with system calls

# Unix
system("clear")
# Windows
system("cls")

Racket

#lang racket
(require (planet neil/charterm:3:0))
(with-charterm
 (void (charterm-clear-screen)))

Raku

(formerly Perl 6)

sub clear { print qx[clear] }
clear;

Retro

clear

REXX

generic

The REXX programming language does not include a facility to clear the screen natively.

However, it is possile to execute an external system command to achieve this task.

Below is some generic-type boilerplate (REXX) code which (possibly) determines:

which REXX is being used
which operating system is being used
which (external) program to clear the screen

Also, not germane to this Rosetta Code task, the boilerplate code also possibly determines (among other things):

if a particular documentation is to be shown
which system pool name is to be used for system environmental variables
which version of REXX is being used
if the program is being invoked as a function, command, or subroutine

The following code works for:

PC/REXX
Personal REXX
CMS REXX
TSO REXX
R4 REXX
ROO REXX
KEXX
REXX compiler
Regina REXX

The intent of the program's boilerplate code is to be able to be executed under most REXXes under most operating systems without changing the boilerplate REXX code.

/*REXX boilerplate determines how to clear screen (under various REXXes)*/
trace off;      parse arg !            /*turn off tracing; get C.L. args*/
if !all(arg())  then exit              /*Doc request?   Show, then exit.*/
if !cms then address ''                /*Is this CMS?  Use this address.*/

!cls                                   /*clear the (terminal) screen.   */            /* ◄═══   this is where  "it"  happens.*/

exit                                   /*stick a fork in it, we're done.*/
/*═════════════════════════════general 1-line subs══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════*/
!all:  !!=!;!=space(!);upper !;call !fid;!nt=right(!var('OS'),2)=='NT';!cls=word('CLS VMFCLEAR CLRSCREEN',1+!cms+!tso*2);if arg(1)\==1 then return 0;if wordpos(!,'? ?SAMPLES ?AUTHOR ?FLOW')==0 then return 0;!call=']$H';call '$H' !fn !;!call=;return 1
!cal:  if symbol('!CALL')\=="VAR" then !call=; return !call
!env:  !env='ENVIRONMENT'; if !sys=='MSDOS'|!brexx|!r4|!roo then !env='SYSTEM'; if !os2 then !env='OS2'!env; !ebcdic=1=='f0'x; if !crx then !env='DOS'; return
!fid:  parse upper source !sys !fun !fid . 1 . . !fn !ft !fm .; call !sys; if !dos then do; _=lastpos('\',!fn); !fm=left(!fn,_); !fn=substr(!fn,_+1); parse var !fn !fn '.' !ft; end; return word(0 !fn !ft !fm,1+('0'arg(1)))
!rex:  parse upper version !ver !vernum !verdate .; !brexx='BY'==!vernum; !kexx='KEXX'==!ver; !pcrexx='REXX/PERSONAL'==!ver|'REXX/PC'==!ver; !r4='REXX-R4'==!ver; !regina='REXX-REGINA'==left(!ver,11); !roo='REXX-ROO'==!ver; call !env; return
!sys:  !cms=!sys=='CMS'; !os2=!sys=='OS2'; !tso=!sys=='TSO'|!sys=='MVS'; !vse=!sys=='VSE'; !dos=pos('DOS',!sys)\==0|pos('WIN',!sys)\==0|!sys=='CMD'; !crx=left(!sys,6)=='DOSCRX'; call !rex; return
!var:  call !fid; if !kexx then return space(dosenv(arg(1))); return space(value(arg(1),,!env))

Regina

The regina interpreter supports the rexxcurses plugin, which provides a facility to clear the screen (not shown here).

Ring

system('clear')

RPL

CLLCD

Ruby

system 'clear'

Or, without reliance on the command line: (equivalent to `clear`)

puts "\e[H\e[2J"

Probably more platform-independent:

require 'io/console'
STDOUT.clear_screen

Rust

print!("\x1B[2J");

Or using casting:

print!("{}[2J", 27 as char);

Scala

Library: Scala

object Cls extends App {print("\033[2J")}

Seed7

The function clear is portable and clears the console window. Clear is based on terminfo respectively the Windows console API. A portable function to clear cannot rely on shell respectively cmd.exe commands, because Windows uses CLS and Unix shells use CLEAR, to clear a screen. ANSI terminal escape sequences are also not 100% portable, since not all terminals accept them.

$ include "seed7_05.s7i";
  include "console.s7i";

const proc: main is func
  local
    var text: console is STD_NULL;
  begin
    console := open(CONSOLE);
    clear(console);
    # Terminal windows often restore the previous
    # content, when a program is terminated. Therefore
    # the program waits until Return/Enter is pressed.
    readln;
  end func;

Sidef

Using a cached-function:

func clear { print(static x = `clear`) };
clear();

Directly invoking the `clear` command:

Sys.run('clear');

Alternatively, without reliance on the command line:

print "\e[3J\e[H\e[2J";

Smalltalk

Transcript clear.

SmileBASIC

SmileBASIC's text screen is mixed in with its graphics screen, background screen, and sprites screen.

Text screen only

To clear just the text screen:

CLS

All screens

Clearing all of the screens, and resetting display options can be done with:

ACLS

SPL

#.clear()

Standard ML

Works with: Unix

fun clearScreen () =
  let
    val strm = TextIO.openOut (Posix.ProcEnv.ctermid ())
  in
    TextIO.output (strm, "\^[[H\^[[2J");
    TextIO.closeOut strm
  end

Stata

The cls command clears the Results window, which is the closest to a terminal in Stata.

Tcl

This only works on systems with ANSI terminal handling, i.e., Unix platforms.

puts -nonewline "\033\[2J"
flush stdout

UNIX Shell

The clear command can be used to clear the terminal screen:

Works with: Bourne Shell

clear

# Alternative method using tput
tput clear

Visual Basic .NET

System.Console.Clear()

Works on all .NET Core platforms. Throws an exception if output has been redirected to a file.

Wren

System.print("\e[2J")

XPL0

code Clear=40;
Clear;

Yabasic

clear screen

zkl

System.cmd(System.isWindows and "cls" or "clear");
// or, for ANSI terminals: print("\e[2J")