Not necessarily complete, but still a good reference for tools is the tool list maintained at W3C. And it is a wiki, so if something is missing, add it!

• Command line (conversion, validation, query): apt-get install redland-utils;
• Conversion webservices: Morph, triplr;
• ORM (Python): RDFAlchemy and SURF;
• General Python framework: rdflib;
• Namespace lookup: prefix.cc;
• Quick registration of properties: OpenVocab;
• Testing schema publication/linked data: Vapour;
• Browsing links, de-referencing, ... : Tabulator.

For most day to day activities I'm using the Talis Platform, accessed by my Ruby client Pho. (Disclaimer: I work for Talis) Pho also includes a general purpose SPARQL client.

I also use Redland very heavily both on the command-line (rapper is great) and via its Ruby bindings which I use in Pho.

When programming in Java I use Jena and in particular its TDB backend which is a native triple store. TDB has some command-line scripts that make it very easy to process, munge, and query data from the command-line.

There are, of course, commercial solutions available as well.

My company, Cambridge Semantics, offers a few products known collectively as Anzo that our customers use to build solutions using Semantic Web technologies. The center of our software is our server component, which is also available as open-source at http://openanzo.org . The server provides:

• Client development libraries in Java, JavaScript, and .NET
• A named-graph-based RDF store
• Access control at the named graph level
• Versioning (keep past histories of graphs)
• Notification (subscription to real-time events when graphs or patterns change)
• Replication (maintain local caches/replicas of subsets of the server database)
• Standard stuff: read graphs, write graphs, query graphs with SPARQL

We've built and sell two products on top of this server:

• Anzo for Excel - take arbitrary spreadsheet data and link it to schemas/ontologies, turning the spreadsheet into a user interface for RDF data (and pulling RDF data out of existing spreadsheets)
• Anzo on the Web - let non-technical users build views (lenses) of their RDF data with an Exhibit-like faceted-browsing interface

I'm using several triple stores. And actually still evaluating them. So far I got some experience with:

• OpenLink Virtuoso Open Source edition
• Oracle 11g
• Ontotext Owlim/BigOwlim
• Sesame
• TopBraid Composer

Currently looking into:

• Intellidimension Semantic.Server and SDK (looks very promising for .Net world)
• NeOnToolkit

In PHP, ARC, Moriarty, with Talis store as backend, morph.talis.com as JSONP proxy, and prefix.cc for cutting and pasting namespace URIs (rdf, rdfs and owl ns uris are long to type). RdfQuery for javascript ?

From the command line I use redland's rapper utility. I find it really handy for exploring a linked data space, and outputting stuff as Turtle.

rapper -o turtle http://dbpedia.org/resource/Semantic_Web

When I'm wanting to look at some bigger pools of rdf I've used python's rdflib, with the Sleepycat backend, which can handle millions of triples easily, and is very simple to use. SPARQL support isn't really all there...but it has nice methods for digging into the triples from python, and that has been enough for me.

ed@rorty:~$ python
Python 2.6.4 (r264:75706, Dec  7 2009, 18:43:55) 
[GCC 4.4.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import rdflib
>>> graph = rdflib.Graph('Sleepycat')
>>> graph.open('my-store', create=True)
>>> graph.parse('http://dbpedia.org/resource/Semantic_Web')
>>> for object in graph.objects(predicate=rdflib.namespace.OWL.sameAs):
...   print object
... 
http://dbpedia.org/resource/Semantic_Web
http://rdf.freebase.com/ns/guid.9202a8c04000641f8000000000039a20

When it comes to publishing semantic web data I've been taking the somewhat lazy approach of focusing on having good RESTful practices and converting to an RDF serialization as late as possible--just like people do with HTML representations. This means I am not really limited to a semantic web technology stack, and can use more familiar web frameworks (django, rails, etc) with relational or nosql database backends. Maybe this isn't really isn't "doing" semantic web software development, but it suits me ok :-)

Obviously I am biased because I'm CTO at Talis, but I use the Talis Platform (http://www.talis.com/platform)

For creating some of my linked data sites I've used:

Talis Platform Paget Moriarty Arc2

For ontology editting/reasoning:

Protege 4 Pellet Fact++ Hermit

Triplestores:

4store Sesame TDB

You can use an abstraction over Jena or Sesame, like RDF2Go (Java); or you can use Jena or Sesame APIs directly.

Other notable Java triple/quadstores are JRDF (jrdf.sourceforge.net) and Mulgara (www.mulgara.org).

Most of the stores can provide their own HTTP endopoint for SPARQL queries and even for updates (in various flavors), therefore you can program in anything that can do HTTP requests and can parse XML or JSON.

I use Sesame and Virtuoso, with queries directed through the HTTP SPARQL interface on Virtuoso instead of the other possible methods.

Using right now:

• Blipkit (Prolog based package tailored to the life sciences. LGPL)

I generally use Jena for work-based projects.

I've also dabbled with Redland in an Objective-C project.

Javascript libraries

For web apps in the past I have used RDF Parser Thingy http://www.jibbering.com/rdf-parser/ (BSD license)

More recently I prefer the excellent jQuery plugin rdfquery, which supports parsing and creating RDFa in web pages, as well as parsing, manipulating, querying and serializing RDF. (linked in kwijibo's post)(MIT license)

I use RDF.rb and Spira for parsing and manipulating RDF data with Ruby, rdfQuery when working with JavaScript and jQuery, AWK and Raptor on the command line, Sesame and Cassandra for querying and storage, and prefix.cc for namespace lookup.

Openlink Virtuoso OS, ARC 2, homegrown custom scripts, redland/rapper, apache mod's such as mod_authn_webid and _everyone from Joe Presby, mod_cern_meta is very handy too. Altova SemanticWorks for owl generation and analysis.

will be adding rdfquery, cwm and probably squin to the mix v soon.

Important are C libraries Redland, which also have bindings for Perl, PHP, Python and Ruby.

PHP+MySQL developers will be interested in ARC2.

I use(d):

• Jena (Java)
• Virtuoso Open Source edition.
• Pellet: OWL reasoner (Java, GPL license)

Not used yet, but looking interesting:

• RDF2Go: uniform API to Jena and Sesame (Java, New-BSD license)
• Java-RDFa: RDF extraction from HTML+RDFa documents (Java, MIT or BSD?)

I'm working on my own .Net library which is in fairly early Alpha still:

• dotNetRDF

I also use Talis and Virtuoso which are both supported in my library and I use Jena sometimes

Using:

• SuRF, Object - RDF Mapper built on top of rdflib
• Virtuoso open-source edition (via its HTTP SPARQL endpoint)

I recommend the ROWLEX Toolkit for .NET users. It is the best. I made it ;-)

I used Sesame for a university project.

I've never used SurfRDF but it looks interesting

Mostly using Sesame, and Jena for everything that Sesame does not provide. And also, Oracle Semantic Technologies