Sstrhsrtj

In addition to Martin's answer, I thought it might be useful to explain why LaTeX creates all these extra files. Let's take the example of the .aux file.

Let's say you have a label in your document and a reference to it somewhere above where the label occurs. When pdflatex reads your .tex file, it reads the ref first. Now, it doesn't know what to do with this ref: it hasn't yet encountered what it's referring to. Now when pdflatex reaches the label, it makes a note of what the label is referring to. By "makes a note" I mean it writes something to the .aux file that says roughly "when you encounter references to this, this is what is meant".

Then, on a second pdflatex run, when it reaches the reference, it looks in the .aux file and it knows what it is supposed to refer to and can substitute in the relevant text.

Auxiliary files are used for lots of other similar things (like tables of contents, lists of figures and so on). They are annoying, but deleting them after each run would break things. A lot.

You already got lots of very good answers explaining why pdflatex needs all those auxiliary files. However you might still feel frustrated about having to live with all those files polluting a directory where (I'm guessing) you would like to keep all your LaTeX documents and their corresponding .pdf outputs.

The best solution is to keep one directory for each document you have.

You can keep, for example, a main Documents folder and then individual Paper1, Paper2, ... folders; each with their own main.tex file. Then you can happily let LaTeX store whatever auxiliary files it wants in their respective folders. The difference is that now, for you, there is a clear structure of where your documents are.

TeX writes the .log file. It contains more information about processing the job than what is shown on the console. It's very useful for debugging.

LaTeX writes the .aux and .toc files. They are used for managing cross-references and table-of-contents information. Since TeX's organism digests the input document from beginning to end, once per job, there's no other way to have a part of the document change based on later content.

The beamer class writes .snm and .nav files. The .snm file is to assist you with including images of slides into an article version of the document. The .nav file assists in creating navigation bars on slides. Beamer is not apparently set up to suppress writing those files if they are not needed (i.e., if you do not need the functionality they enable).

The hyperref package writes the .out file to assist in creating bookmarks in the pdf file. Sometimes this isn't needed; I looked at the last few jobs I had which used hyperref and the .out files are empty. Again, this doesn't seem suppressable.

You can write the auxiliary files to a temporary directory. Then you'll have to instruct TeX to look in that temporary directory. Also you will have to make sure that the included auxiliary files are the right ones, not ones placed in the temporary directory by another process.

I think it's best to learn to live with these files. If you don't want them after you're "done" with writing the document, just delete them.

This is quite an old post with many good answers but, surprisingly, none of them mention nofiles. There are times when you create documents with:

• no cross references (with ref and label)


• no citations (with cite)


• no table of contents.

In these cases you don't want latex to create the long list of files mentioned above and you can tell it not to using nofiles:

documentclass{article}

nofiles

begin{document}

  Hello world

end{document}

If you are running (pdf)latex "by hand" then the only files created will be the .log file and the .dvi (or .pdf file). If you are using something ike synctex then there will be a few more files for controlling the automatic compilation.

You can use this workaround as a rough guide because I am not sure whether you are a Windows user.

Step 1: create a batch file

rem batch.bat takes a input name without extension.

echo off



rem remove the previous PDF output to avoid confusion

rem when compilation fails.

del %1.pdf



pdflatex %1

pdflatex %1

rem list other programs such as

rem invoking bibtex, etc.



del %1.log

del %1.aux

del %1.nav

del %1.out

del %1.toc



rem other operations such as deleting or

rem renaming files.

Save it in a dedicated, safe folder such that reformatting hard disk will not lose it.

Step 2: set the PATH

Step 3: Configure TeXnicCenter

Solution for Emacs with AucTeX, just run

M-x TeX-clean

This does not get rid of any temporary directories that are created, just files

I have the (Mac) application Hazel watching my Articles folder and subfolders, with rules that delete all these auxiliary files after a certain interval since they were last modified. Usually it's two days or so. It cleans up files for papers I'm not currently working on.

Addressing the concerns about deletion raised above, if such files are needed in the future they can be created anew. Though this will require multiple runs, latexmk automatically runs the tex engine the necessary number of times, so they will be created.

For those like-minded as me, and running linux:

#! /bin/bash



echo -n > .hidden

for i in *.out; do echo "$i" >> .hidden; done

for i in *.log; do echo "$i" >> .hidden; done

for i in *.aux; do echo "$i" >> .hidden; done

for i in *.bbl; do echo "$i" >> .hidden; done

for i in *.blg; do echo "$i" >> .hidden; done

for i in *.dvi; do echo "$i" >> .hidden; done

for i in *.toc; do echo "$i" >> .hidden; done

for i in *.synctex.gz; do echo "$i" >> .hidden; done

Put this bash shell in your path, to do that put this line:

export PATH=$PATH:∼/scripts

into your ∼/.bashrc file
(in this example ~/scripts is the folder containing the bash shell above), this can be at the end of that file. Maybe you also have to run this file from the terminal, but this will ensure you can run this script anywhere, wherever you're keeping it.

Now you run this script in the terminal, while being in the directory needing cleaning and run the shell. That means that if the script is named tex.clean, you'd browse to the folder needing cleaning in terminal, enter

tex.clean

in the terminal, and browse to the file in the graphical file browser, and it should be clean :)

All the file with endings mentioned in the shell will be written to that directory's .hidden file. This means they will be hidden, but still usable :).

In nautilus (at least in fedora distributions) ctrl+h will show or hide hidden files.

P.S. I tried to have this as detailed as I could so people new to bash and command line like me could use this. I hope I succeeded :).

Though this is an older question, I want to contribute something that might help people who love clean workspaces. I created a shell script that deletes all junk files at once. It will work on Mac and Linux; with some adjustments Windows should be possible too. Download the file "cleanlatexjunk.sh" from my repository and follow the instructions:

https://github.com/cgraumann/LatexUtils

1. Open Preferences/Build in TexStudio


2. Select Advanced options at the bottom


3. Add a new user command with the name cleanjunk
   


4. As the command, enter:
   
"/PATH/TO/SCRIPT/cleanlatexjunk.sh" -fp ?me ?a)

   and change /PATH/TO/SCRIPT/ accordingly


5. In the meta-command for Build & View add | txs:///cleanjunk at the end

Important: As described by people before, the "junk" files are actually needed. Therefore you should also adjust your build workflow to do multiple compiles in a row. This assures that all TOCs and links are rendered correctly. After two or three compile runs, you can safely use my script as described.

Now every build & view execution should result in a clean workspace :-)

# write a makefile and remove all of the unwanted files after compilation.   

# change your folder structure as you see fit. 

# Folder structure

DOCDIR = doc/

TEXDIR = doc/tex/ 



# The compiler and the -output-directory flag

TCC = pdflatex

TEXFLAGS = -output-directory 



documentation: 

        $(TCC) $(TEXFLAGS) $(DOCDIR) $(TEXDIR)filename1.tex 

        $(TCC) $(TEXFLAGS) $(DOCDIR) $(TEXDIR)filename2.tex 

        $(TCC) $(TEXFLAGS) $(DOCDIR) $(TEXDIR)filename3.tex 

        rm -f $(DOCDIR)*.log 

        rm -f $(DOCDIR)*.aux            

        rm -f $(DOCDIR)*.toc 

        rm -f *.pdf

        rm -f *.aux 

        rm -f *.toc 

        rm -f *.log 



# Though if using this method you have to be careful with the image paths in  

# your tex source file. They're taken from the makefile directory.



# To use the file type >> make documentation << in a terminal 



# You can also do it like this



documentation: 

        $(TCC) $(TEXFLAGS) $(DOCDIR) $(TEXDIR)filename1.tex 

        $(TCC) $(TEXFLAGS) $(DOCDIR) $(TEXDIR)filename2.tex 

        $(TCC) $(TEXFLAGS) $(DOCDIR) $(TEXDIR)filename3.tex 



clean: 

        rm -f $(DOCDIR)*.log 

        rm -f $(DOCDIR)*.aux            

        rm -f $(DOCDIR)*.toc 

        rm -f *.pdf

        rm -f *.aux 

        rm -f *.toc 

        rm -f *.log 



# now >> make clean documentation << outputs with no crappy files

# and >> make documentation << outputs with the crappy files

# and >> make clean << cleans all the crappy files.

Going back to why so many extra files (and why the C compiler doesn’t – apparently – do this): C is a language designed for single-pass compilation. Names must be defined before used. LaTeX isn’t. In a world with tight memory, the way to handle this is to use two passes, storing information needed for the second pass on the way through.

In today’s world with big memories, this is not entirely necessary. A LaTeX compiler could in principle store everything needed in internal tables and go back and patch in information as it became available.

If you really want to manage this properly, you need to work out how to use a makefile (or other similar build manager) to decide automatically when a second run is needed (some cases are obvious, like when you change your bibliography, others less so). Read this if you want to find out about Makefiles and LaTeX in detail.

For Mac OS X 18.* users (I'm using Mountain Lion) the .hidden file list does not appear to work any more for Finder. An alternative to the previous script would be

for i in *.{out,log,aux,toc,bbl,dvi,blg,synctex.gz};

    do chflags hidden $i;

done

which also works in some flavors of Linux.

There's still another option, you can merge the Clean button and the close button in TexMaker so when you close all the auxiliary files are deleted. This way you don't have to remember to Clean all the time yet you can still use the auxiliary files as long as you don't close.

This can be done downloading the sourcecode. The important file is texmaker.cpp and the processes are CleanAll and fileClose

Texmaker includes an option to "use a build directory for output files" which kind of does the trick.

If you enable this setting Texmaker creates a 'build' folder in the same directory as the document .tex file. It automatically cleans the old output and outputs into the build folder instead.

The setting works well but isn't perfect. For example I've found that after adding a new citation to the document Bibtex complained when it couldn't find the .aux file. I had to copy the aux file back out of the build folder to compile the document. I'm not sure if there's a way to fix that yet.

These files are needed but yes, there's no need to have them at the same path. Use this bash script to avoid cluttering of the folder containing your .tex file:

# plcl: pdflatex clean

infile=`readlink -f "$1"`

inpath=`dirname "$infile"`

tmpath="/tmp/pdflatex`echo "$inpath" | sed -e 's///-/g'`"



mkdir "$tmpath"

pdflatex -output-directory "$tmpath" "$1"

mv "$tmpath"/*pdf "$inpath"

This requires bash and sed.

The LaTeX build wrapper ltx2any may be a solution. This does not prevent the creation of all the auxiliary files, but places them in another directory, which you can specify

ltx2any -t path_where_you_want_the_auxiliary_files_to_go filename.tex 

This path can very well be a tmp folder.

For more options, see ltx2any --help.

Just do it: It's dirty but useful.

cd /usr/bin && mv pdflatex __backup_real_pdflatex

vim pdflatex

#!/bin/bash



fname="$1"

/usr/bin/__backup_real_pdflatex $@ && rm -f "$fname."{log,nav,out,aux,toc,snm}

exit $?

WARNING: The script above is not tested even once!!