write(3): on file - Linux man page (2023)


This manual page is part of the POSIX Programmer's Manual. The Linux implementation of thisinterface may differ (consult the corresponding Linux manual page for details of Linux behavior), or the interface may not be implemented on Linux.


pwrite, write - write on a file


#include <unistd.h>

ssize_t pwrite(int fildes, const void *buf, size_t nbyte,
off_t offset);
ssize_twrite(int fildes, const void *buf, size_t nbyte);


The write() function shall attempt to write nbyte bytes from the buffer pointed to by buf to the file associated with the open filedescriptor, fildes.

Before any action described below is taken, and if nbyte is zero and the file is a regular file, the write() function may detect and returnerrors as described below. In the absence of errors, or if error detection is not performed, the write() function shall return zero and have no otherresults. If nbyte is zero and the file is not a regular file, the results are unspecified.

On a regular file or other file capable of seeking, the actual writing of data shall proceed from the position in the file indicated by the file offsetassociated with fildes. Before successful return from write(), the file offset shall be incremented by the number of bytes actually written. On aregular file, if this incremented file offset is greater than the length of the file, the length of the file shall be set to this file offset.

On a file not capable of seeking, writing shall always take place starting at the current position. The value of a file offset associated with such a deviceis undefined.

If the O_APPEND flag of the file status flags is set, the file offset shall be set to the end of the file prior to each write and no intervening filemodification operation shall occur between changing the file offset and the write operation.

If a write() requests that more bytes be written than there is room for (for example, the process' file size limit or the physical end of a medium),only as many bytes as there is room for shall be written. For example, suppose there is space for 20 bytes more in a file before reaching a limit. A write of512 bytes will return 20. The next write of a non-zero number of bytes would give a failure return (except as noted below).

If the request would cause the file size to exceed the soft file size limit for the process and there is no room for any bytes to be written, the requestshall fail and the implementation shall generate the SIGXFSZ signal for the thread.

If write() is interrupted by a signal before it writes any data, it shall return -1 with errno set to [EINTR].

(Video) Write you own man page in Linux - The basics

If write() is interrupted by a signal after it successfully writes some data, it shall return the number of bytes written.

If the value of nbyte is greater than {SSIZE_MAX}, the result is implementation-defined.

After a write() to a regular file has successfully returned:

Any successful read() from each byte position in the file that was modified by that write shall return the data specified by the write() forthat position until such byte positions are again modified.
Any subsequent successful write() to the same byte position in the file shall overwrite that file data.

Write requests to a pipe or FIFO shall be handled in the same way as a regular file with the following exceptions:

There is no file offset associated with a pipe, hence each write request shall append to the end of the pipe.
Write requests of {PIPE_BUF} bytes or less shall not be interleaved with data from other processes doing writes on the same pipe. Writes of greater than{PIPE_BUF} bytes may have data interleaved, on arbitrary boundaries, with writes by other processes, whether or not the O_NONBLOCK flag of the file statusflags is set.
If the O_NONBLOCK flag is clear, a write request may cause the thread to block, but on normal completion it shall return nbyte.
If the O_NONBLOCK flag is set, write() requests shall be handled differently, in the following ways:
The write() function shall not block the thread.
A write request for {PIPE_BUF} or fewer bytes shall have the following effect: if there is sufficient space available in the pipe, write() shalltransfer all the data and return the number of bytes requested. Otherwise, write() shall transfer no data and return -1 with errno set to[EAGAIN].
A write request for more than {PIPE_BUF} bytes shall cause one of the following:
When at least one byte can be written, transfer what it can and return the number of bytes written. When all data previously written to the pipe is read,it shall transfer at least {PIPE_BUF} bytes.
When no data can be written, transfer no data, and return -1 with errno set to [EAGAIN].

When attempting to write to a file descriptor (other than a pipe or FIFO) that supports non-blocking writes and cannot accept the data immediately:

If the O_NONBLOCK flag is clear, write() shall block the calling thread until the data can be accepted.
If the O_NONBLOCK flag is set, write() shall not block the thread. If some data can be written without blocking the thread, write() shallwrite what it can and return the number of bytes written. Otherwise, it shall return -1 and set errno to [EAGAIN].

Upon successful completion, where nbyte is greater than 0, write() shall mark for update the st_ctime and st_mtime fields of thefile, and if the file is a regular file, the S_ISUID and S_ISGID bits of the file mode may be cleared.

For regular files, no data transfer shall occur past the offset maximum established in the open file description associated with fildes.

If fildes refers to a socket, write() shall be equivalent to send() with no flags set.

If the O_DSYNC bit has been set, write I/O operations on the file descriptor shall complete as defined by synchronized I/O data integrity completion.

If the O_SYNC bit has been set, write I/O operations on the file descriptor shall complete as defined by synchronized I/O file integrity completion.

If fildes refers to a shared memory object, the result of the write() function is unspecified.

If fildes refers to a typed memory object, the result of the write() function is unspecified.

(Video) Troff Tutorial: How To Write A Linux Man Page With Troff

If fildes refers to a STREAM, the operation of write() shall be determined by the values of the minimum and maximum nbyte range (packetsize) accepted by the STREAM. These values are determined by the topmost STREAM module. If nbyte falls within the packet size range, nbyte bytesshall be written. If nbyte does not fall within the range and the minimum packet size value is 0, write() shall break the buffer into maximumpacket size segments prior to sending the data downstream (the last segment may contain less than the maximum packet size). If nbyte does not fallwithin the range and the minimum value is non-zero, write() shall fail with errno set to [ERANGE]. Writing a zero-length buffer ( nbyte is0) to a STREAMS device sends 0 bytes with 0 returned. However, writing a zero-length buffer to a STREAMS-based pipe or FIFO sends no message and 0 is returned.The process may issue I_SWROPT ioctl() to enable zero-length messages to be sent across the pipe or FIFO.

When writing to a STREAM, data messages are created with a priority band of 0. When writing to a STREAM that is not a pipe or FIFO:

If O_NONBLOCK is clear, and the STREAM cannot accept data (the STREAM write queue is full due to internal flow control conditions), write() shallblock until data can be accepted.
If O_NONBLOCK is set and the STREAM cannot accept data, write() shall return -1 and set errno to [EAGAIN].
If O_NONBLOCK is set and part of the buffer has been written while a condition in which the STREAM cannot accept additional data occurs, write()shall terminate and return the number of bytes written.

In addition, write() shall fail if the STREAM head has processed an asynchronous error before the call. In this case, the value of errno doesnot reflect the result of write(), but reflects the prior error.

The pwrite() function shall be equivalent to write(), except that it writes into a given position without changing the file pointer. The firstthree arguments to pwrite() are the same as write() with the addition of a fourth argument offset for the desired position inside the file.

Return Value

Upon successful completion, write() and pwrite() shall return the number of bytes actually written to the file associated with fildes.This number shall never be greater than nbyte. Otherwise, -1 shall be returned and errno set to indicate the error.


The write() and pwrite() functions shall fail if:

The O_NONBLOCK flag is set for the file descriptor and the thread would be delayed in the write() operation.
The fildes argument is not a valid file descriptor open for writing.
An attempt was made to write a file that exceeds the implementation-defined maximum file size or the process' file size limit, and there was no room forany bytes to be written.
The file is a regular file, nbyte is greater than 0, and the starting position is greater than or equal to the offset maximum established in theopen file description associated with fildes.
The write operation was terminated due to the receipt of a signal, and no data was transferred.
The process is a member of a background process group attempting to write to its controlling terminal, TOSTOP is set, the process is neither ignoring norblocking SIGTTOU, and the process group of the process is orphaned. This error may also be returned under implementation-defined conditions.
There was no free space remaining on the device containing the file.
An attempt is made to write to a pipe or FIFO that is not open for reading by any process, or that only has one end open. A SIGPIPE signal shall also besent to the thread.
The transfer request size was outside the range supported by the STREAMS file associated with fildes.

The write() function shall fail if:


The file descriptor is for a socket, is marked O_NONBLOCK, and write would block.

A write was attempted on a socket that is not connected.
A write was attempted on a socket that is shut down for writing, or is no longer connected. In the latter case, if the socket is of type SOCK_STREAM, theSIGPIPE signal is generated to the calling process.

The write() and pwrite() functions may fail if:

The STREAM or multiplexer referenced by fildes is linked (directly or indirectly) downstream from a multiplexer.
A physical I/O error has occurred.
Insufficient resources were available in the system to perform the operation.
A request was made of a nonexistent device, or the request was outside the capabilities of the device.
A hangup occurred on the STREAM being written to.

A write to a STREAMS file may fail if an error message has been received at the STREAM head. In this case, errno is set to the value included in theerror message.

The write() function may fail if:

A write was attempted on a socket and the calling process does not have appropriate privileges.
A write was attempted on a socket and the local network interface used to reach the destination is down.

A write was attempted on a socket and no route to the network is present.

(Video) Mastering Linux Man Pages - A Definitive Guide

The pwrite() function shall fail and the file pointer remain unchanged if:

The offset argument is invalid. The value is negative.
fildes is associated with a pipe or FIFO.

The following sections are informative.


Writing from a Buffer

The following example writes data from the buffer pointed to by buf to the file associated with the file descriptor fd.

#include <sys/types.h>#include <string.h>...char buf[20];size_t nbytes;ssize_t bytes_written;int fd;...strcpy(buf, "This is a test\n");nbytes = strlen(buf);bytes_written = write(fd, buf, nbytes);...

Application Usage



See also the RATIONALE section in read().

An attempt to write to a pipe or FIFO has several major characteristics:

Atomic/non-atomic: A write is atomic if the whole amount written in one operation is not interleaved with data from any other process. This isuseful when there are multiple writers sending data to a single reader. Applications need to know how large a write request can be expected to be performedatomically. This maximum is called {PIPE_BUF}. This volume of IEEE Std 1003.1-2001 does not say whether write requests for more than {PIPE_BUF} bytes areatomic, but requires that writes of {PIPE_BUF} or fewer bytes shall be atomic.
Blocking/immediate: Blocking is only possible with O_NONBLOCK clear. If there is enough space for all the data requested to be written immediately,the implementation should do so. Otherwise, the process may block; that is, pause until enough space is available for writing. The effective size of a pipe orFIFO (the maximum amount that can be written in one operation without blocking) may vary dynamically, depending on the implementation, so it is not possible tospecify a fixed value for it.
Complete/partial/deferred: A write request:
int fildes;size_t nbyte;ssize_t ret;char *buf;ret = write(fildes, buf, nbyte);

may return:




This shall never happen if nbyte<= {PIPE_BUF}. If it does happen (with nbyte> {PIPE_BUF}), this volume of IEEE Std 1003.1-2001 does notguarantee atomicity, even if ret<= {PIPE_BUF}, because atomicity is guaranteed according to the amount requested, not the amountwritten.

ret=-1, errno=[EAGAIN]

This error indicates that a later request may succeed. It does not indicate that it shall succeed, even if nbyte<= {PIPE_BUF}, because ifno process reads from the pipe or FIFO, the write never succeeds. An application could usefully count the number of times [EAGAIN] is caused by a particularvalue of nbyte> {PIPE_BUF} and perhaps do later writes with a smaller value, on the assumption that the effective size of the pipe may havedecreased.

Partial and deferred writes are only possible with O_NONBLOCK set.

The relations of these properties are shown in the following tables:

(Video) Using Linux Man Pages | Command Line Tips

l l l l.

If the O_NONBLOCK flag is clear, a write request shall block if the amount writable immediately is less than that requested. If the flag is set (byfcntl()), a write request shall never block.

l l l l.

There is no exception regarding partial writes when O_NONBLOCK is set. With the exception of writing to an empty pipe, this volume of IEEE Std 1003.1-2001does not specify exactly when a partial write is performed since that would require specifying internal details of the implementation. Every application shouldbe prepared to handle partial writes when O_NONBLOCK is set and the requested amount is greater than {PIPE_BUF}, just as every application should be preparedto handle partial writes on other kinds of file descriptors.

The intent of forcing writing at least one byte if any can be written is to assure that each write makes progress if there is any room in the pipe. If thepipe is empty, {PIPE_BUF} bytes must be written; if not, at least some progress must have been made.

Where this volume of IEEE Std 1003.1-2001 requires -1 to be returned and errno set to [EAGAIN], most historical implementations return zero (with theO_NDELAY flag set, which is the historical predecessor of O_NONBLOCK, but is not itself in this volume of IEEE Std 1003.1-2001). The error indications in thisvolume of IEEE Std 1003.1-2001 were chosen so that an application can distinguish these cases from end-of-file. While write() cannot receive anindication of end-of-file, read() can, and the two functions have similar return values. Also, some existing systems (for example, Eighth Edition)permit a write of zero bytes to mean that the reader should get an end-of-file indication; for those systems, a return value of zero from write()indicates a successful write of an end-of-file indication.

Implementations are allowed, but not required, to perform error checking for write() requests of zero bytes.

The concept of a {PIPE_MAX} limit (indicating the maximum number of bytes that can be written to a pipe in a single operation) was considered, but rejected,because this concept would unnecessarily limit application writing.

See also the discussion of O_NONBLOCK in read().

Writes can be serialized with respect to other reads and writes. If a read() of file data can be proven (by any means) to occur after awrite() of the data, it must reflect that write(), even if the calls are made by different processes. A similar requirement applies to multiplewrite operations to the same file position. This is needed to guarantee the propagation of data from write() calls to subsequent read() calls.This requirement is particularly significant for networked file systems, where some caching schemes violate these semantics.

Note that this is specified in terms of read() and write(). The XSI extensions readv() and writev() also obey these semantics. Anew "high-performance" write analog that did not follow these serialization requirements would also be permitted by this wording. This volume of IEEE Std1003.1-2001 is also silent about any effects of application-level caching (such as that done by stdio).

This volume of IEEE Std 1003.1-2001 does not specify the value of the file offset after an error is returned; there are too many cases. For programmingerrors, such as [EBADF], the concept is meaningless since no file is involved. For errors that are detected immediately, such as [EAGAIN], clearly the pointershould not change. After an interrupt or hardware error, however, an updated value would be very useful and is the behavior of many implementations.

This volume of IEEE Std 1003.1-2001 does not specify behavior of concurrent writes to a file from multiple processes. Applications should use some form ofconcurrency control.

Future Directions


(Video) Shell Basics - Read and Write to Files - Linux Tutorial #3

See Also

chmod(), creat(), dup(), fcntl(), getrlimit(), lseek(), open(), pipe(), ulimit(),writev(), the Base Definitions volume of IEEE Std 1003.1-2001, <limits.h>, <stropts.h>, <sys/uio.h>,<unistd.h>


Portions of this text are reprinted and reproduced in electronic form from IEEE Std 1003.1,2003 Edition, Standard for Information Technology -- Portable Operating System Interface (POSIX), The Open Group Base Specifications Issue 6, Copyright ©2001-2003 by the Institute of Electrical and Electronics Engineers, Inc and The Open Group. In the event of any discrepancy between this version and theoriginal IEEE and The Open Group Standard, the original IEEE and The Open Group Standard is the referee document. The original Standard can be obtained onlineat http://www.opengroup.org/unix/online.html .


What does man man do in Linux? ›

man command in Linux is used to display the user manual of any command that we can run on the terminal. It provides a detailed view of the command which includes NAME, SYNOPSIS, DESCRIPTION, OPTIONS, EXIT STATUS, RETURN VALUES, ERRORS, FILES, VERSIONS, EXAMPLES, AUTHORS and SEE ALSO. 1.

What does man 2 mean in Linux? ›

Man pages are organized in sections, e.g. Section 1 includes all user command man pages, Section 2 all man pages for the system calls, Section 3 is for library functions etc.

What does write () return? ›

The write function returns the number of bytes successfully written into the file, which may at times be less than the specified nbytes.

What is Linux man page? ›

Man pages are simply manual pages created to help users understand how commands are used in Linux. These pages are installed, by default, alongside the commands. As long as the software developer created a man page, it'll be there to help explain how to use a specific command.

What does '|' mean in Linux? ›

The vertical bar connects the commands together, making it possible to create a chain of related but separate processes. This approach is used extensively in Unix and Linux systems to build multiprocess pipelines in shell programs such as sh, csh, tcsh, ksh and bash.

What is the meaning of ~/? ›

~ means the home directory of the logged on user whereas ~/ means the path to the beginning of a directory. From here: The tilde (~) is a Linux "shortcut" to denote a user's home directory. Thus tilde slash (~/) is the beginning of a path to a file or directory below the user's home directory.

How to use man command Linux? ›

How to Use man in Linux. In the terminal window, type man followed by the Linux command name which man page you want to see. The output is lengthy. Use the mouse scroll wheel, the up and down arrow keys, or the PgDn and PgUp keys to navigate through it.

What is write () function? ›

The write() function writes nbyte bytes from buf to the file or socket associated with file_descriptor. nbyte should not be greater than INT_MAX (defined in the <limits. h> header file). If nbyte is zero, write() simply returns a value of zero without attempting any other action.

How to write function in Linux? ›

using function keyword : A function in linux can be declared by using keyword function before the name of the function. Different statements can be separated by a semicolon or a new line. 2. using parenthesis : A function can also be declared by using parenthesis after the name of the function.

Why do we write return 1? ›

return 1: A return 1 means that there is some error while executing the program, and it is not performing what it was intended to do.

What is the format of a man page? ›

The default format of man pages is troff, with either the macro package man (appearance oriented) or mdoc (semantic oriented). This makes it possible to typeset a man page into PostScript, PDF, and various other formats for viewing or printing.

What is the content of section 3 of Linux man pages? ›

Section 1 of the man pages covers command-line tools, section 2 covers system calls, section 3 covers user-space libraries, and so on. If you don't specify a section, man displays the page from the first section that has a matching entry.

How do I find a man page in Linux? ›

To search a specific man page section, use the -s option with the man command and the -k or -K option. Note - Keywords are contained within double quotation marks.

What is the purpose of a man page? ›

It provides users with detailed documentation for included software programs, system commands, formal standards and conventions, and operating system nuances such as system and library calls. The man page is usually invoked through the command "man," followed by the object, command name or topic, e.g., "man shell."

How are Linux man pages organized? ›

Man pages are divided into sections referenced by numbers:
  • General user commands.
  • System calls.
  • Library functions.
  • Special files and drivers.
  • File formats.
  • Games and screensavers.
  • Miscellanea.
  • System administration commands and daemons.
Jul 12, 2017

How do I get the man page? ›

A user can request to display a man page by simply typing man followed by a space and then argument. Here its argument can be a command, utility or function. A manual page associated with each of these arguments is displayed.

What is Linux command list? ›

The ls command is used to list files or directories in Linux and other Unix-based operating systems. Just like you navigate in your File explorer or Finder with a GUI, the ls command allows you to list all files or directories in the current directory by default, and further interact with them via the command line.

What are Linux file commands? ›

file command is used to determine the type of a file. .file type may be of human-readable(e.g. 'ASCII text') or MIME type(e.g. 'text/plain; charset=us-ascii'). This command tests each argument in an attempt to categorize it.

What is Linux command example? ›

The which command facilitates with only one option that is the '-a' option. It is used to display all the paths for the specified command. In some cases, our machine contains two different paths for the same program. For example, it can be "/usr/bin/program" or "/usr/local/bin/program".

What is $# in Linux? ›

The special character $# stores the total number of arguments. We also have $@ and $* as wildcard characters which are used to denote all the arguments. We use $$ to find the process ID of the current shell script, while $? can be used to print the exit code for our script.

What does '|' symbol do in command? ›

One of the most powerful shell operators is the pipe ( | ). The pipe takes output from one command and uses it as input for another. And, you're not limited to a single piped command—you can stack them as many times as you like, or until you run out of output or file descriptors.

What does $* mean in Unix? ›

$* means pass all parameters to the function as a single 'parameter'. It's also advised to have double quotes around such variable "$*" .

Why is the meaning of 3? ›

The number 3 has always held powerful symbolism. Think about good things coming in 3s, the birth-life-death cycle, the mind-body-soul connection, the 3 acts of a typical story. Wherever the number 3 shows up in your life, it's generally an omen of creativity, communication, optimism, and curiosity!

What is a better word for it? ›

The words this and that can be used in place of it when referring to something that's near, understood, or previously mentioned or indicated. They can also be used for emphasis.

What is the meaning of this symbol (#)? ›

Answer. The symbol known as the hashtag (#) in Twitter has a history of different names and uses in American English, including pound sign – used after a number to mean “weight in pounds,” number sign – used in front of a number to mean “number” (as in "Please review item #2 on the list"), crosshatch, and hash mark.

How do you add a man entry? ›

To add an additional directory of man pages, you can set the $MANPATH environment variable. Prefix $MANPATH with a : to have it added to the list of already-configured man paths.
The general process is like this:
  1. Create a text file with markup.
  2. Pass it through a sed script to format it for nroff.
  3. Pass it through nroff.

Where are man pages? ›

Manual pages are normally stored in nroff(1) format under a directory such as /usr/share/man. In some installations, there may also be preformatted cat pages to improve performance. See manpath(5) for details of where these files are stored.

How to create a file in Linux? ›

To create a new file, run the "cat" command and then use the redirection operator ">" followed by the name of the file. Now you will be prompted to insert data into this newly created file. Type a line and then press "Ctrl+D" to save the file. $ cat > secondFile.

What are the types of functions write example? ›

Types of Function - Based on Equation

Constant Function: The polynomial function of degree zero. Linear Function: The polynomial function of degree one. Quadratic Function: The polynomial function of degree two. Cubic Function: The polynomial function of degree three.

What is write data? ›

The writedata function writes numeric data from a Maple vector, matrix, list, or list of lists into a text file fileID.

How do you write a function example? ›

An example of a simple function is f(x) = x2. In this function, the function f(x) takes the value of “x” and then squares it. For instance, if x = 3, then f(3) = 9. A few more examples of functions are: f(x) = sin x, f(x) = x2 + 3, f(x) = 1/x, f(x) = 2x + 3, etc.

How do you write a function code? ›

To create your own function, you need to do four things:
  1. Write the return type of the function.
  2. Write the name of the function.
  3. Inside parenthesis () , list any parameters the function takes.
  4. Inside curly brackets {} , write the code that will run whenever the function is called. This is called the body of the function.

What is the use of man command? ›

The man command provides reference information on topics, such as commands, subroutines, and files. The man command provides one-line descriptions of commands specified by name. The man command also provides information on all commands whose descriptions contain a set of user-specified keywords.

What does the man man command line display? ›

man Page Organization and Structure

The man command is used to display the user manual of a command. Usually, the argument given to man is the name of a program, a utility, or a function. Thus, the manual page related to each of these arguments is then found and displayed.

How do you use a man file? ›

To use man , you type man on the command line, followed by a space and a Linux command. man opens the Linux manual to the “man page” that describes that command—if it can find it, of course. The man page for man opens.

What does the man command do in Linux quizlet? ›

The man man command opens the most recent log file. (The man command is short for manual and is used to obtain documentation about a Linux command. The command man man would provide documentation about how to use the manual.)

How to use man command in Unix? ›

The "man" is a short term for manual page. In unix like operating systems such as linux, man is an interface to view the system's reference manual. A user can request to display a man page by simply typing man followed by a space and then argument. Here its argument can be a command, utility or function.

How do I navigate a man in Linux? ›

Navigating and searching man pages

b ^B ESC-v * Backward one window (or N lines). z * Forward one window (and set window to N). w * Backward one window (and set window to N). ESC-SPACE * Forward one window, but don't stop at end-of-file.

Where are man pages stored in Linux? ›

The man pages are stored in /usr/share/man.

What are the man page sections? ›

man page sections

Section # 1 : User command (executable programs or shell commands) Section # 2 : System calls (functions provided by the kernel) Section # 3 : Library calls (functions within program libraries) Section # 4 : Special files (usually found in /dev)

What can I learn from man pages? ›

A man page is a piece of documentation that is distributed and read digitally. Almost every package you install on a UNIX-based OS will include some type of man page. These documents cover topics from: programs, command-line tools, system calls, and even abstract concepts.

How many sections are in the man? ›

Enter man followed by the name of the command. The Unix manual consists of eight sections, and each man page has its command name followed by the section number in parenthesis. Note that if you are a user, you will be using the commands in section 1.

Which of the following commands searches man pages? ›

To search a specific man page section, use the -s option with the man command and the -k or -K option.

What is the alternate command of man *? ›

Cheat is another useful alternative to man pages to learn Unix commands. It allows you to create and view interactive Linux/Unix commands cheatsheets on the command-line. The recommended way to install Cheat is using Pip package manager.

What are the 5 basic components of Linux quizlet? ›

Just like any other typical operating system, Linux has all of these components: kernel, shells and GUIs, system utilities, and an application program.


(Pranjal Das)
2. Linux Man Pages - A Quick Tutorial
(Linux Training Academy)
3. The Man Pages
(EF - Linux Made Simple)
4. Writing Your Own And Editing Existing Linux (Manual) Man Pages
(Computer Freedom)
5. Three Manpage Alternatives - bropages, cheat and tldr
6. Manual Pages
Top Articles
Latest Posts
Article information

Author: Geoffrey Lueilwitz

Last Updated: 01/26/2023

Views: 5564

Rating: 5 / 5 (80 voted)

Reviews: 95% of readers found this page helpful

Author information

Name: Geoffrey Lueilwitz

Birthday: 1997-03-23

Address: 74183 Thomas Course, Port Micheal, OK 55446-1529

Phone: +13408645881558

Job: Global Representative

Hobby: Sailing, Vehicle restoration, Rowing, Ghost hunting, Scrapbooking, Rugby, Board sports

Introduction: My name is Geoffrey Lueilwitz, I am a zealous, encouraging, sparkling, enchanting, graceful, faithful, nice person who loves writing and wants to share my knowledge and understanding with you.