TkCVS(1)

📦 version 8.2.3, in debian bookworm, debian trixie, ubuntu jammy, ubuntu noble, ubuntu questing

💖 TkCVS 💖

okay bestie, welcome to the General Commands Manual page for TkCVS(1) — yes, the whole thing, and no I'm not skipping anything, sit down, grab a snack 🍓

✨ NAME ✨

TkCVS — a Tk/Tcl graphical interface to CVS and Subversion. it's giving "fancy windows for your version control," and honestly? iconic 👑

✨ SYNOPSIS ✨

tkcvs [-dir directory] [-root cvsroot] [-win workdir|module|merge] [-log file]

✨ DESCRIPTION ✨

so TkCVS is a Tcl/Tk-based graphical interface to the CVS and Subversion configuration management systems. it shows you the status of the files in your current working directory, and hands you buttons and menus so you can run configuration-management commands on whatever files you've selected. it also has limited RCS functionality. and TkDiff is bundled in there too, for browsing and merging your changes. slay 💅

TkCVS also helps you browse the repository, which is lowkey the best part. for Subversion, the repository tree gets browsed like an ordinary file tree. for CVS, the CVSROOT/modules file is read. TkCVS extends CVS with a method to produce a browsable, "user friendly" listing of modules. this requires special comments in the CVSROOT/modules file. see "CVS Modules File" for more guidance 🫶

✨ OPTIONS ✨

TkCVS accepts the following options, bestie, here we go:

-dir directory — start TkCVS in the specified directory.
-help — print a usage message.
-log file — invoke a log browser for the specified file. -log and -win are mutually exclusive 👀
-root cvsroot — set $CVSROOT to the specified repository.
-win workdir|module|merge — start by displaying the directory browser (that's the default), the module browser, or the directory-merge tool. -win and -log are mutually exclusive.

✨ Examples ✨

% tkcvs -win module -root /jaz/repository

Browse the modules located in CVSROOT /jaz/repository 🌸

% tkcvs -log tstheap.c

View the log of the file tstheap.c ✨

✨ Working Directory Browser ✨

the working directory browser shows the files in your local working copy, aka your "sandbox." it shows the status of the files at a glance and gives you tools for basically all the common CVS, SVN, and RCS operations you might do. very main character energy, truly.

at the top of the browser you will find:

The name of the current directory. you can change directories by typing in this field. recently visited directories are saved in the picklist 📋
The relative path of the current directory in the repository. if it is not contained in the repository you may import it using the menu or toolbar button.
A Directory Tag name, if the directory is contained in the repository and it has been checked out against a particular branch or tag. in Subversion, the branch or tag is inferred from the URL based on the conventional trunk-branches-tags repository organization.
The CVSROOT of the current directory if it's under CVS control, or the URL of the Subversion repository if it's under Subversion control. if neither is true, it may default to the value of the $CVSROOT environment variable.

the main part of the working directory browser is a list of the files in the current directory, with an icon next to each one showing its status. you select a file by clicking on its name or icon once with the left mouse button. holding the Control key while clicking will add the file to the group of those already selected. you can select a contiguous group of files by holding the Shift key while clicking. you can also select a group of files by dragging the mouse with the middle or right button pressed to select an area. selecting an item that's already selected de-selects that item. to unselect all files, click the left mouse button in an empty area of the file list. yes, all of that, i know, but it's all real 💀

The Date column (can be hidden) shows the modification time of the file. the format of the date column may be specified with cvscfg(dateformat). the default format was chosen because it sorts the same way alphabetically as chronologically. clever right? no cap.
If the directory belongs to a revision system, other columns are present:
The revision column shows which revision of the file is checked out, and whether it's on the trunk or on a branch.
The status column (can be hidden) shows the revision of the file spelled out in text. this information is mostly redundant to the icon in the file column.
The Editor/Author/Locker column (can be hidden) varies according to revision system. in Subversion, the author of the most recent checkin is shown. in CVS, it shows a list of people editing the files if your site uses cvs watch and/or cvs edit. otherwise, it will be empty. in RCS, it shows who, if anyone, has the file locked.

the optional columns can be displayed or hidden using the Options menu 🎀

you can move into a directory by double-clicking on it.

double clicking on a file will load the file into a suitable editor so you can change it. a different editor can be used for different file types (see Configuration Files).

🌈 File Status 🌈

when you are in a directory that is under CVS or Subversion control, the file status will be shown by an icon next to each file. checking the "Status Column" option causes the status to be displayed in text in its own column. some possible statuses are:

Up-to-date — the file is up to date with respect to the repository.
Locally Modified — the file has been modified in the current directory since being checked out of the repository.
Locally Added — the file has been added to the repository. this file will become permanent in the repository once a commit is made.
Locally Removed — you have removed the file with remove, and not yet committed your changes.
Needs Checkout — someone else has committed a newer revision to the repository. the name is slightly misleading; you will ordinarily use update rather than checkout to get that newer revision.
Needs Patch — like Needs Checkout, but the CVS server will send a patch rather than the entire file. sending a patch or sending an entire file accomplishes the same thing.
Needs Merge — someone else has committed a newer revision to the repository, and you have also made modifications to the file.
Unresolved Conflict — this is like Locally Modified, except that a previous update command gave a conflict. you need to resolve the conflict before checking in. do not skip this one bestie 😭
? — the file is not contained in the repository. you may need to add the file to the repository by pressing the "Add" button.
[directory:CVS] — a directory which has been checked out from a CVS repository.
[directory:SVN] — the file is a directory which has been checked out from a Subversion repository. in Subversion, directories are themselves versioned objects.
[directory:RCS] — a directory which contains an RCS sub-directory or some files with the ,v suffix, presumably containing some files that are under RCS revision control.
[directory] — the file is a directory.

🌸 File Filters 🌸

you can specify file matching patterns to instruct TkCVS which files you wish to see. you can also specify patterns telling it which files to remove when you press the "Clean" button or select the File->Cleanup menu item.

"Hide" works exactly the way a .cvsignore file works. that is, it causes non-CVS files with the pattern to be ignored. it's meant for hiding .o files and such. any file under CVS control will be listed anyway.

"Show" is the inverse. it hides non-CVS files except for those with the pattern. periodt.

🦋 Buttons 🦋

Module Browser: the big button at the upper right opens the module browser. opens a module browser window which will enable you to explore items in the repository even if they're not checked out. in CVS, this requires that there be entries in the CVSROOT/modules file. browsing can be improved by using TkCVS-specific comments in CVSROOT/modules.
Go Up: the button to the left of the entry that shows the current directory. press it and you go up one level.

there are a number of buttons at the bottom of the window. pressing on one of these causes the following actions:

Delete: press this button to delete the selected files. the files will not be removed from the repository. to remove the files from the repository as well as delete them, press the "Remove" button instead.
Edit: press this button to load the selected files in to an appropriate editor.
View: press this button to view the selected files in a Tk text window. this can be a lot faster then Edit, in case your preferred editor is xemacs or something of that magnitude 💀
Refresh: press this button to re-read the current directory, in case the status of some files may have changed.
Status Check: shows, in a searchable text window, the status of all the files. by default, it is recursive and lists unknown (?) files. these can be changed in the Options menu.
Directory Branch Browse: for merging the entire directory. in Subversion, it opens the Branch Browser for "." in CVS, it chooses a "representative" file in the current directory and opens a graphical tool for directory merges.
Log (Branch) Browse: this button will bring up the log browser window for each of the selected files in the window. see the Log Browser section.
Annotate: this displays a window in which the selected file is shown with the lines highlighted according to when and by whom they were last revised. in Subversion, it's also called "blame." 🫣
Diff: this compares the selected files with the equivalent files in the repository. a separate program called "TkDiff" (also supplied with TkCVS) is used to do this. for more information on TkDiff, see TkDiff's help menu.
Merge Conflict: if a file's status says "Needs Merge", "Conflict", or is marked with a "C" in CVS Check, there was a difference which CVS needs help to reconcile. this button invokes TkDiff with the -conflict option, opening a merge window to help you merge the differences.
Check In — this is the button that ships your changes to the repository, and it handles everything: new files get added, deleted files get removed. Press it and a dialog pops up asking for a version number and a comment. You only need to type a version number if you want the repo copy to jump to the next major version. Like, say a file is at version 1.10 and you leave the version box empty — it gets checked in as 1.11. But if you type 3, it's checked in as 3.0 instead. Honestly tho, using symbolic tags for that is usually the better move. If you're using rcsinfo to supply a comment template, you have to use an external editor — set cvscfg(use_cvseditor) for that. And for checking in to RCS, an external editor is always used. 💅
Update — refreshes your sandbox directory with whatever the other devs have committed to the repository.
Update with Options — lets you update from a different branch, with a tag, with empty directories, and so on. ✨
Add Files — press this when you want new files in the repository. You must create the file first, bestie — no adding ghosts. Select the files you want and hit Add Files. They get committed next time you press Check In. Heads up: it is not recursive. For that, go to the menu CVS -> Add Recursively.
Remove Files — this one removes files. Select them, press Remove. They vanish from the directory, and they're removed from the repository the next time you press Check In. Also not recursive — use the menu CVS -> Remove Recursively for the recursive version.
Tag — tags the selected files. In CVS, the -F (force) option will move the tag if it already exists on the file.
Branch Tag — tags the selected files, but this time it creates a branch. In CVS, the -F (force) option will move the tag if it already exists on the file.
Lock (CVS and RCS) — locks an RCS file for editing. If cvscfg(cvslock) is set, it locks a CVS file. Locking is philosophically discouraged in CVS because it's literally against the "concurrent" part of Concurrent Versioning System 🙈 but some sites run a locking policy anyway. One size doesn't fit all, fr fr.
Unlock (CVS and RCS) — unlocks an RCS file. If cvscfg(cvslock) is set, it unlocks a CVS file.
Set Edit Flag (CVS) — sets the edit flag on the selected files so other developers can see you're currently editing them (see "cvs edit" in the CVS documentation).
Reset Edit Flag (CVS) — resets the edit flag on the selected files so other developers can see you're done editing them (see "cvs edit" in the CVS documentation). Okay so here's the messy part: the current version of cvs waits on a prompt for "cvs unedit" if changes have been made to that file — it wants to ask whether you'd like to revert to the current revision. So the current action of tkcvs is to abort the unedit by piping nothing into stdin. Which means: to actually lose your changes and revert to the current revision, you have to delete the file and do an update (that also clears the edit flag). And to keep your changes? Copy the file, delete the original, update, then move the saved copy back to the original filename. 😭
Close — closes the Working Directory Browser. If no other windows are open, TkCVS exits.

🌈 Log (Branch) Browser 🌈

The TkCVS Log Browser window gives you a graphical display of a file's revision log — every previous version, plus any branched versions. It's iconic, genuinely.

You can reach the log browser window three ways:

Invoke it directly with tkcvs [-log] <filename>
Select a file in the main window of TkCVS and press the Log Browse button
Select a file in a list invoked from the module browser and press the Log Browse button

If the Log Browser is looking at a checked-out file, the buttons for performing merge operations get enabled. 🫶

🎀 Log Browser Window 🎀

The log browser window has three components:

the file name and version information section at the top
the log display in the middle
a row of buttons along the bottom

🦋 Log Display 🦋

The main log display is pretty self explanatory ngl. It shows a group of boxes connected by lines — the lines show the main trunk of the file's development (that's the left hand side) and any branches the file has (which spread out to the right of the main trunk).

Each box contains the version number, the author of that version, and other info determined by the menu View -> Revision Layout.

Constructing the branch diagram from Subversion is inefficient, so the Log Browser counts the tags when it does a Subversion diagram and pops up a dialog giving you a chance to skip the tag step if there are too many tags. And "many" arbitrarily equals 10. 💀

✨ Version Numbers ✨

Once a file is loaded into the log browser, you can select one or two version numbers.

The primary version (Selection A) is selected by clicking the left mouse button on a version box in the main log display.

The secondary version (Selection B) is selected by clicking the right mouse button on a version box in the main log display.

Operations like View and Annotate operate only on the primary version selected.

Operations like Diff and Merge Changes to Current need two versions selected. 👑

🔍 Searching the Diagram 🔍

You can search the canvas for tags, revisions, authors, and dates.

These special characters are used in the search pattern:

* — Matches any sequence of characters in string, including a null string.
? — Matches any single character in string.
[chars] — Matches any character in the set given by chars. If a sequence of the form x-y appears in chars, then any character between x and y, inclusive, will match.
\x — Matches the single character x. This provides a way of avoiding the special interpretation of the characters *?[] in pattern.

If you only enter "FOO" (without the

💖 Log Browser Buttons 💖

The log browser contains the following buttons:

Refresh — re-reads the revision history of the file.
View — displays a Tk text window containing the version of the file at Selection A.
Annotate — displays a window in which the file is shown with its lines highlighted according to when and by whom they were last revised. In Subversion, it's also called "blame."
Diff — runs the "tkdiff" program to display the differences between version A and version B.
Merge — to use this button, select a branch version of the file, other than the branch you're currently on, as the primary version (Selection A). The changes made along the branch up to that version get merged into the current version, and stored in the current directory. Optionally, select another version (Selection B) and the changes will be from that point rather than from the base of the branch. The version of the file in the current directory will be merged, but no commit will occur. Then you inspect the merged files, correct any conflicts which may occur, and commit when you're satisfied. Optionally, TkCVS will tag the version that the merge is from — it suggests a tag of the form "mergefrom_<rev>_date." If you use this auto-tagging function, another dialog containing a suggested tag for the merged-to version will appear. It's suggested to leave the dialog up until you're finished, then copy-and-paste the suggested tag into the "Tag" dialog. It is always a good practice to tag when doing merges, and if you use tags of the suggested form, the Branch Browser can diagram them. (Auto-tagging is not implemented in Subversion because, despite the fact that tags are "cheap," it's somewhat impractical to auto-tag single files. You can do the tagging manually, however.)
View Tags — lists all the tags applied to the file in a searchable text window.
Close — closes the Log Browser. If no other windows are open, TkCVS exits.

The View Menu lets you control what you see in the branch diagram. You can choose how much information to show in the boxes, whether to show empty revisions, and whether to show tags. You can even control the size of the boxes. If you're using Subversion, you may wish to turn the display of tags off — if they aren't asked for they won't be read from the repository, which can save a lot of time. ⭐

💅 Merge Tool for CVS 💅

The Merge Tool chooses a "representative" file in the current directory and diagrams the branch tags. It tries to pick the "bushiest" file, or failing that, the most-revised file. If you disagree with its choice, you can type the name of another file in the top entry and press Return to diagram that file instead. Main character energy, honestly.

The main purpose of this tool is to do merges (cvs update -j rev [-j rev]) on the whole directory. For merging one file at a time, you should use the Log Browser. You can only merge to the line (trunk or branch) that you're currently on. Select a branch to merge from by clicking on it. Then press either the "Merge" or "Merge Changes" button. The version of the file in the current directory will be over-written, but it will not be committed to the repository. You do that after you've reconciled conflicts and decided if it's what you really want.

Merge Branch to Current — the changes made on the branch since its beginning will be merged into the current version.
Merge Changes to Current — instead of merging from the base of the branch, this button merges the changes that were made since a particular version on the branch. It pops up a dialog in which you fill in the version. It should usually be the version that was last merged.

🌸 Module Browser 🌸

Okay bestie, listen up 💅 — when you wanna do stuff on the repository itself instead of inside a checked-out working directory, that's the Module Browser's whole job. And the most iconic thing it does? Checking out or exporting from the repository, obviously. ✨

You can launch it from the command line:

tkcvs -win module

...or just hit the big button in the main window. Either way, she's ready. 🫶

Subversion repositories? You can literally browse them like a file tree, and that's exactly what you'll see in the Module Browser. 🌈 CVS repositories are not directly browsable, no cap — but if the CVSROOT/modules file is maintained properly, TkCVS can show you the modules and even infer tree structures if they exist. Peep the "CVS Modules File" section for that. 👀

In the module browser window you pick a module and check it out. When you check out a module, a new directory gets created in the current working directory, and it has the same name as the module. Simple as that. 💖

✨ Tagging and Branching (cvs rtag) ✨

You can tag particular versions of a module or file in the repository, with plain tags or branch tags, and you don't even need the module checked out. Queen behaviour honestly. 👑

✨ Exporting ✨

Once a release has been tagged, you can do a special kind of checkout called an export. This lets you cleanly check out files from the repository without all the administrivia CVS needs while you're actively working on files. Perfect for delivering a software release to a customer. 🎁

✨ Importing ✨

TkCVS has a special dialog so users can import brand-new files into the repository. In CVS, new modules can be assigned places inside the repository, plus descriptive names (so other people actually know what they're for). 💜

When the Module Browser is showing a CVS repository, the first column is a tree showing the module codes and directory names of everything in the repository. The icon tells you whether the item is a directory (which may contain other directories or modules) or a module (which can be checked out from TkCVS). And yes, an item can be both a module and a directory — she contains multitudes. 🌸

If it has a red ball on it 🔴 → you can check it out.
If it shows a plain folder icon 📁 → you have to open the folder to get to the items you can check out.

To select a module, click it with the left mouse button. The right mouse button does a secondary selection, which is only used for Subversion diff and patch. To clear a selection, click the item again or click in an empty area of the module column. There can only be one primary and one secondary selection. Periodt. 💅

✨ Repository Browser Buttons ✨

The module browser contains the following buttons:

Who: — Shows which modules are checked out by whom. 🕵️
Import: — Imports the contents of the current directory (the one shown in the Working Directory Display) into the repository as a module. See the section titled Importing for more info.
File Browse: — Displays a list of the selected module's files. From that file list you can view the file, browse its revision history, or see a list of its tags. 🔍
Check Out: — Checks out the current version of a module. A dialog lets you specify a tag, change the destination, and so on.
Export: — Exports the current version of a module. A dialog lets you specify a tag, change the destination, and so on. Export is like check-out, except exported directories do not contain the CVS or administrative directories, so they're cleaner — but they cannot be used for checking files back into the repository. ⚠️ You must supply a tag name when exporting a module, to make sure you can reproduce the exported files later.
Tag: — This button tags an entire module.
Branch Tag: — This creates a branch of a module by giving it a branch tag. 🌿
Patch Summary: — Displays a short summary of the differences between two versions of a module.
Create Patch File: — Creates a Larry Wall format patch(1) file of the module you selected.
Close: — Closes the Repository Browser. If no other windows are open, TkCVS exits. 👋

🦋 Importing New Modules 🦋

Before importing a new module, first check that you actually have write permission to the repository. Also you'll have to make sure the module name isn't already in use. No duplicate names, bestie, it's giving chaos otherwise. 😭

To import a module you first need a directory where the module lives. Make sure there's nothing in that directory except the files you want to import. Nothing. Zero. Zilch. 🧹

Press the big "Repository Browser" button in the top part of the tkcvs UI, or use CVS -> Import WD into Repository from the menu bar.

In the module browser, press the Import button at the bottom — the one showing a folder and an up arrow. ⬆️

In the dialog that pops up, fill in a descriptive title for the module. This is what you'll see on the right side of the module browser. ✨

OK the dialog. Several things happen now:

The directory is imported
The CVSROOT/module file is updated
Your original directory is saved as directory.orig
The newly created module is checked out

When it finishes, you should find the original Working Directory Browser showing the files in the newly created, checked-out module. Slay. 🎀

Here's a more detailed description of the fields in the Import Dialog.

Module Name: — A name for the module. This name must not already exist in the repository. Your organization could settle on a single unambiguous code for modules. One possibility is something like:

[project code]-[subsystem code]-[module code]

Module Path: — The location in the repository tree where your new module will go.
Descriptive Title: — A one-line descriptive title for your module. This will be displayed in the right-hand column of the browser.
Version Number: — The current version number of the module. This should be a number of the form X.Y.Z where .Y and .Z are optional. You can leave this blank, in which case 1 will be used as the first version number.

Importing a directory into Subversion is similar but not so complicated. You use the SVN -> Import CWD into Repository menu. You need supply only the path in the repository where you want the directory to go. The repository must be prepared and the path must exist, however. 🫡

💜 Importing to an Existing Module (CVS) 💜

Before importing to an existing module, first check to make sure you have write permission to the repository.

To import to an existing module you first need a directory where the code lives. Make sure there's nothing in this directory (including no CVS directory) except the files you want to import. ⚠️

Open up the Repository Browser by selecting File/Browse Modules from the menu bar.

In the Repository Browser, select File/Import To An Existing Module from the menu bar.

In the dialog that pops up, press the Browse button and select the name of an existing module. Press OK to close this dialog box. Enter the version number of the code to be imported.

OK the dialog. Several things happen now:

The directory is imported
Your original directory is saved as directory.orig
The newly created module is checked out

When it finishes, you'll find the original Working Directory Browser showing the original code. If you press the "Re-read the current directory" button you'll see the results of the checked-out code. 🔥

Here's a more detailed description of the fields in the Import Dialog.

Module Name: — A name for the existing module. Filled in by the use of the the Browse button.
Module Path: — The location in the repository tree where the existing module is. Filled in by the use of the Browse button.
Version Number: — The current version number of the module to be imported. This should be a number of the form X.Y.Z where .Y and .Z are optional. You can leave this blank, in which case 1 will be used as the first version number.

🌈 Vendor Merge (CVS) 🌈

Software development is sometimes based on a source distribution from a vendor or third-party distributor. After building a local version of that distribution, merging or tracking the vendor's future release into the local version can be done with the vendor merge command. 🤝

The vendor merge command assumes that a separate module has already been defined for the vendor or third-party distribution, using the "Import To A New Module" and "Import To An Existing Module" commands. It also assumes a separate module has already been defined for the local code that the vendor merge operation will be applied to.

Start from an empty directory and invoke tkcvs. Open up the Repository Browser by selecting File/Browse Modules from the menu bar.

Checkout the module of the local code to be merged with changes from the vendor module. (Use the red icon with the down arrow 🔻)

In the Repository Browser, after verifying that the Module entry box still has the name of the module of the local code to which the vendor code is to be merged into, select File/Vendor Merge from the menu bar.

In the Module Level Merge With Vendor Code window, press the Browse button to select the module to be used as the vendor module.

OK the dialog. All revisions from the vendor module will be shown in the two scroll lists. Fill in the From and To entry boxes by clicking in the appropriate scroll lists. OK the dialog. Several things happen now — several screens will appear showing the output from cvs commands for:

checking out temp files
cvs merge
cvs rdiff

Information in these screens will tell you what routines will have merge conflicts and what files are new or deleted. After perusing the files, close each screen. 🧐

(In the preceeding dialog box, there was an option to save outputs from the merge and rdiff operations to files CVSmerge.out and CVSrdiff.out.)

The checked-out local code will now contain changes from a merge between two revisions of the vendor modules. This code will not be checked into the repository. You can do that after you've reconciled conflicts and decide if that's really what you want. 💅

A detailed example on how to use the vendor merge operation is provided in the PDF file vendor5readme.pdf. 📄

🎀 Configuration Files 🎀

okay bestie, listen up, TkCVS has two config files and you're gonna want to know about both 💖

The first one lives in the directory where all the *.tcl files for TkCVS got installed. It's called tkcvs_def.tcl. You can also drop a file called site_def in that same directory — that's a chef's kiss spot for site-specific stuff like tagcolours. And here's the slay part: unlike tkcvs_def.tcl, it does not get overwritten when you install a newer version of TkCVS. iconic behavior honestly 👑

Values in the site config files can be over-ridden at the user level by putting a .tkcvs file in your home directory. Commands in either of these files use Tcl syntax. So like, to set a variable name, you'd have this in your .tkcvs file:

set variablename value

for example:

set cvscfg(editor) "gvim"

The following variables are supported by TkCVS 👇

🌱 Startup

cvscfg(startwindow) — which window you want to see when you start up. (workdir or module)

🐘 CVS

cvscfg(cvsroot) — if you set this, it overrides the CVSROOT environment variable.

🦋 Subversion

If your SVN repository has a structure similar to trunk, branches, and tags but with different names, you can tell TkCVS about it by setting variables in tkcvs_def.tcl:

set cvscfg(svn_trunkdir) "elephants"
set cvscfg(svn_branchdir) "dogs"
set cvscfg(svn_tagdir) "ducklings"

The branch browser depends on the convention of having a trunk, branches, and tags structure to draw the diagram. These variables may give you a little more flexibility.

🎨 GUI

Most colors and fonts can be customized using the options database. For example, you can add lines like these to your .tkcvs file:

option add *Canvas.background #c3c3c3
option add *Menu.background #c3c3c3
option add *selectColor #ffec8b
option add *Text.background gray92
option add *Entry.background gray92
option add *Listbox.background gray92
option add *ToolTip.background LightGoldenrod1
option add *ToolTip.foreground black

cvscfg(picklist_items) — max number of visited directories and repositories to save in the picklist history.

📜 Log browser

cvscfg(colourA), cvscfg(colourB) — hilight colours for revision-log boxes ✨
cvscfg(tagdepth) — number of tags you want to see for each revision on the branching diagram before it says "more..." and offers a pop-up to show the rest.
cvscfg(toomany_tags) — number of tags in a Subversion repository that's "too many", i.e. will take longer to process for the branch diagram than you're willing to wait. (Building a branch diagram for Subversion is very inefficient 😭.) If there are more than that number and cvscfg(confirm_prompt) is true, a dialog will appear asking whether to process the tags or to draw the diagram without them.
cvscfg(tagcolour,tagstring) — colors for marking tags. For example:

set cvscfg(tagcolour,tkcvs_r6) Purple

📦 Module browser

cvscfg(aliasfolder) — in the CVS module browser, if true this will cause the alias modules to be grouped in one folder. Cleans up clutter if there are a lot of aliases. tidy queen 🧹

🫶 User preferences

cvscfg(allfiles) — set this to false to see normal files only in the directory browser. Set it to true to see all files including hidden files. 👀
cvscfg(auto_status) — set the default for automatic status-refresh of a CVS controlled directory. Automatic updates are done when a directory is entered and after some operations.
cvscfg(auto_tag) — whether to tag the merged-from revision when using TkCVS to merge different revisions of files by default. A dialog still lets you change your mind, regardless of the default.
cvscfg(confirm_prompt) — ask for confirmation before performing an operation (true or false).
cvscfg(dateformat) — format for the date string shown in the "Date" column, for example "%Y/%m/%d %H:%M".
cvscfg(cvslock) — set to true to turn on the ability to use cvs-admin locking from the GUI.
cvscfg(econtrol) — set this to true to turn on the ability to use CVS Edit and Unedit, if your site is configured to allow the feature.
cvscfg(editor) — preferred default editor.
cvscfg(editors) — string pairs giving the editor-command and string-match-pattern, for deciding which editor to use.
cvscfg(editorargs) — command-line arguments to send to the default editing program.
cvscfg(ldetail) — detail level for status reports (latest, summary, verbose).
cvscfg(mergetoformat)
cvscfg(mergefromformat) — format for mergeto- and mergefrom- tags. The _BRANCH_ part must be left as-is, but you can change the prefix and the date format, for example "mergeto_BRANCH_%d%b%y". The date format must be the same for both. CVS rule: a tag must not contain the characters `$,.:;@'
cvscfg(rdetail) — detail for repository and workdir reports (terse, summary, verbose).
cvscfg(recurse) — whether reports are recursive (true or false).
cvscfg(savelines) — how many lines to keep in the trace window.
cvscfg(status_filter) — filter out unknown files (status "?") from CVS Check and CVS Update reports.
cvscfg(use_cvseditor) — let CVS invoke an editor for commit log messages rather than having tkcvs use its own input box. By doing this, your site's commit template (rcsinfo) can be used.

🗂️ File filters

cvscfg(file_filter) — pattern for which files to list. Empty string is equivalent to the entire directory (minus hidden files).
cvscfg(ignore_file_filter) — pattern used in the workdir filter for files to be ignored.
cvscfg(clean_these) — pattern to be used for cleaning a directory (removing unwanted files).

⚙️ System

cvscfg(print_cmd) — system command used for printing. lpr, enscript -Ghr, etc)
cvscfg(shell) — what you want to happen when you ask for a shell.
cvscfg(terminal) — command prefix to use to run something in a terminal window.

🌍 Portability

cvscfg(aster) — file mask for all files (* for Unix, *.* for windows).
cvscfg(null) — the null device. /dev/null for Unix, nul for windows.
cvscfg(tkdiff) — how to start tkdiff. Example sh /usr/local/bin/tkdiff.
cvscfg(tmpdir) — directory in which to do behind-the-scenes checkouts. Usually /tmp or /var/tmp)

🐛 Debugging

cvscfg(log_classes) — for debugging: C=CVS commands, E=CVS stderr output, F=File creation/deletion, T=Function entry/exit tracing, D=Debugging.
cvscfg(logging) — logging (debugging) on or off.

🌈 Environment Variables 🌈

You should have the CVSROOT environment variable pointing to the location of your CVS repository before you run TkCVS. It will still allow you to work with different repositories within the same session, so no stress 💅

If you wish TkCVS to point to a Subversion repository by default, you can set the environment variable SVNROOT. This has no meaning to Subversion itself, but it will clue TkCVS in if it's started in an un-versioned directory.

okay so you can literally extend the TkCVS menu by inserting additional commands into the .tkcvs or tkcvs_def.tcl files. These extensions show up on an extra menu to the right of the TkCVS Options menu. main character energy fr fr 👑

To create new menu entries on the user-defined menu, set the following variables:

🛠️ `cvsmenu(command)`

Setting a variable with this name to a value like "commandname" causes the CVS command cvs commandname to be run when this menu option is selected. For example, the following line:

set cvsmenu(update_A) "update -A"

Causes a new menu option titled "update_A" to be added to the user defined menu that will run the command cvs update -A on the selected files when it is activated.

(This example command, for versions of CVS later than 1.3, will force an update to the head version of a file, ignoring any sticky tags or versions attached to the file).

🛠️ `usermenu(command)`

Setting a variable with this name to a value like "commandname" causes the command commandname to be run when this menu option is selected. For example, the following line:

set usermenu(view) "cat"

Causes a new menu option titled "view" to be added to the User defined menu that will run the command cat on the selected files when it is activated.

Any user-defined commands will be passed a list of file names corresponding to the files selected on the directory listing on the main menu as arguments.

The output of the user defined commands will be displayed in a window when the command is finished. 🎀

🍫 CVS Modules File 🍫

Okay bestie, real talk — if you haven't put anything in your CVSROOT/modules file yet, please go do that. Like, right now. ✨ Peep the "Administrative Files" section of the CVS manual for the deets. Once you've done that, you can drop in comments that TkCVS will actually use — to title your modules and to show them off in a whole tree structure. It's giving organized. 🌳

The most babygirl-simple use of TkCVS's #D directive is just slapping a meaningful title on a module:

#D      softproj        Software Development Projects
softproj softproj

Now for the ✨fancier✨ version: you can arrange your modules into a tree that mimics how they nest inside the repository when they pop up in the module browser. Lowkey iconic.

Say we have a directory called chocolate laid out like this:

chocolate/
    truffle/
        cocoa3/
            biter/
            sniffer/
            snuffler/

To show that whole hierarchy — and make the deepest directories way more accessible by giving them module names — you could put this in the modules file:

#D   chocolate Top Chocolate
#D   chocolate/truffle   Cocoa Level 2
#D   chocolate/truffle/cocoa3 Cocoa Level 3
#D   sniffer   Chocolate Sniffer
sniffer   chocolate/truffle/cocoa3/sniffer
#D   snuff     Chocolate Snuffler
snuff     chocolate/truffle/cocoa3/snuffler
#D   biter     Chocolate Biter
biter     chocolate/truffle/cocoa3/biter

Heads up bestie: when you're installing TkCVS, you might wanna add these extra lines to the modules file — but remember to check out the modules module from the repository first, and then commit it again once you've finished editing. No cap, don't skip that part. 💅

These extension lines all start with a # character, so CVS reads them as plain old comments. That means they're totally safe to leave sitting in the file whether you're using TkCVS or not. 🫶

Also: #M is equivalent to #D. Back in the day the two did different things in older versions of TkCVS, but now? Both get parsed the exact same way. Periodt. 🌈

👀 SEE ALSO 👀

cvs(1)
svn(1)

💖 AUTHOR 💖

Del (del@babel.babel.com.au) — maintenance and Subversion support: Dorothy Robinson 🌸

And that's a wrap on the whole page, bestie!! 🎀 This was TkCVS, version 8.2.3, from the Release era, and yeah — it's literally TkCVS(1). Thanks for reading all the way through, you absolute legend. Go commit something cute. 💜🦋✨

📦 where this page comes from

debian bookworm: tkcvs 8.2.3-1.2
debian trixie: tkcvs 8.2.3-6
ubuntu jammy: tkcvs 8.2.3-1.2
ubuntu noble: tkcvs 8.2.3-1.2
ubuntu questing: tkcvs 8.2.3-6
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on 2026-10-18: a language model's rewrite of the original, under its terms