Academic Statement
The No-Core (F)utility is a minimalist software intervention that interrogates the ideological underpinnings of computational logic and system design. Developed as an unofficial GNU core utility, the work mirrors the canonical yes command—an endlessly affirmative function that outputs the string “yes” until interrupted—but subverts its logic by instead repeating “no” indefinitely. This inversion, while technically trivial, is conceptually potent: it foregrounds the absence of a sanctioned mechanism for refusal within the GNU coreutils and, by extension, within broader digital infrastructures.
The work critiques the structural bias of computational systems toward affirmation, compliance, and repetition. In doing so, it exposes the systemic marginalization of negation and dissent. The title’s parenthetical—core(f)utility—encapsulates the dual nature of the intervention: it is both a utility (a functional tool) and a futility (a gesture of resistance that is ultimately absorbed by the very system it critiques). This duality is central to the work’s philosophical inquiry into the limits of refusal in digital culture.
Torre situates the project within the lineage of software art and conceptual art, aligning it with traditions that use code.
Artistic Statement
No-Core (F)utility is a conceptual and performative intervention into the logic of digital systems. It takes the form of a minimalist, unofficial GNU core utility that mirrors the well-known yes command, but inverts its function. Instead of endlessly affirming, it endlessly refuses. It prints “no”—again and again—until the user stops it.
This work emerged from a simple observation: the official GNU core utilities include a command for “yes,” but not for “no.” That absence is not accidental—it reflects a deeper cultural and technological bias toward affirmation, automation, and compliance. In creating a utility that automates refusal, I wanted to expose the absurdity and futility of negation within a system that is designed to absorb or ignore dissent.
But No-Core (F)utility is not just a joke or a critique. It is also a philosophical gesture. It asks: what does it mean to say “no” in a world where every action is translated into numbers, where every command is a function, and where every refusal is already anticipated by the system? Can we still find space for resistance, for ambiguity, for the unquantifiable?
The work is intentionally minimal. It is built with free and open-source tools. It is not meant to be efficient or useful. It is meant to be a moment of interruption—a loop that refuses to resolve. It is a core utility, but also a core futility. It is a refusal that insists on being heard, even if it changes nothing.
Through this work, I invite the audience to reflect on the politics of code, the aesthetics of refusal, and the possibility of reclaiming agency in a world increasingly governed by digital logic.
The Unofficial GNU “No” core-(f)utility
This is an unofficial GNU coreutils pack that contains the core(f)utility "no"
PROGRAM NAME: "No"
REPEAT
print "n" + carriage return;
UNTIL the program is terminated
END
The above program "No" prints an endless sequence of "n" - one per line - until the user terminates the program. Then, it is recalled in the computer's shell by typing "no" and pressing "Enter". The "no" core(f)util outputs repeatedly your wish for refusal and presents to you its absurdity and (f)utility. ....the official set of GNU core utilities includes a "yes" command. But not a "no". Thus, the coreutils "no" fills this gap. (You are welcome!)... well, this is not the whole story. To get the full picture, install this (f)utility and read the manifesto on the "man no" page
README - (HOW TO INSTALL)
To install this unofficial version of the GNU core utilities that include the “No” core (f)utility do:
- Download the zip HERE
- Open your terminal/shell
cd [to the folder containing the core(f)utilities zip files]
tar -xvf [name of the unzipped folder]
cd [into the unzipped folder]
./configure
make
sudo make install
Done
In Terminal/Shell you can now type the following [Commands]:
no → output repeatedly your wish for refusal and presents to you its absurdity
man no → displays the text submitted to the Transmediale's Almanac 2021 (for Refusal)
Read the article for the Transmediale Almanac at:
https://202122.transmediale.de/almanac/the-no-core-futility-and-the-impossible-refusal
/* The official name of this program (e.g., no 'g' prefix). */
#define PROGRAM_NAME "no"
#include
#include
#include
#include "system.h"
#include "error.h"
#include "full-write.h"
#include "long-options.h"
#define AUTHORS proper_name ("Giuseppe Torre")
void
usage (int status)
{
if (status != EXIT_SUCCESS)
emit_try_help ();
else
{
printf (_("\
Usage: %s [STRING]...\n\
or: %s OPTION\n\
"),
program_name, program_name);
fputs (_("\
Repeatedly output a line with all specified STRING(s), or 'n'.\n\
\n\
"), stdout);
fputs (HELP_OPTION_DESCRIPTION, stdout);
fputs (VERSION_OPTION_DESCRIPTION, stdout);
emit_ancillary_info (PROGRAM_NAME);
}
exit (status);
}
int
main (int argc, char **argv)
{
initialize_main (&argc, &argv);
set_program_name (argv[0]);
setlocale (LC_ALL, "");
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
atexit (close_stdout);
parse_gnu_standard_options_only (argc, argv, PROGRAM_NAME, PACKAGE_NAME,
Version, true, usage, AUTHORS,
(char const *) NULL);
char **operands = argv + optind;
char **operand_lim = argv + argc;
if (optind == argc)
*operand_lim++ = bad_cast ("n");
/* Buffer data locally once, rather than having the
large overhead of stdio buffering each item. */
size_t bufalloc = 0;
bool reuse_operand_strings = true;
char **operandp = operands;
do
{
size_t operand_len = strlen (*operandp);
bufalloc += operand_len + 1;
if (operandp + 1 < operand_lim
&& *operandp + operand_len + 1 != operandp[1])
reuse_operand_strings = false;
}
while (++operandp < operand_lim);
/* Improve performance by using a buffer size greater than BUFSIZ / 2. */
if (bufalloc <= BUFSIZ / 2)
{
bufalloc = BUFSIZ;
reuse_operand_strings = false;
}
/* Fill the buffer with one copy of the output. If possible, reuse
the operands strings; this wins when the buffer would be large. */
char *buf = reuse_operand_strings ? *operands : xmalloc (bufalloc);
size_t bufused = 0;
operandp = operands;
do
{
size_t operand_len = strlen (*operandp);
if (! reuse_operand_strings)
memcpy (buf + bufused, *operandp, operand_len);
bufused += operand_len;
buf[bufused++] = ' ';
}
while (++operandp < operand_lim);
buf[bufused - 1] = '\n';
/* If a larger buffer was allocated, fill it by repeating the buffer
contents. */
size_t copysize = bufused;
for (size_t copies = bufalloc / copysize; --copies; )
{
memcpy (buf + bufused, buf, copysize);
bufused += copysize;
}
/* Repeatedly output the buffer until there is a write error; then fail. */
while (full_write (STDOUT_FILENO, buf, bufused) == bufused)
continue;
error (0, errno, _("standard output"));
return EXIT_FAILURE;
}